Synapse/pl: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Synapse ułatwia użycie portu szeregowego i dostarcza synchroniczną bibliotekę TCP/IP.
2	2
3	3		## Przegląd
4	4
5	5		Synapse oferuje obsługę portu [[Hardware Access\|szeregowego]] oraz łączność TCP/IP. Różni się od innych bibliotek tym, że wymaga jedynie dodania do kodu kilku plików kodu źródłowego Synapse Pascal; nie ma potrzeby instalowania całych pakietów itp. Jedynym wyjątkiem jest to, że będziesz potrzebować zewnętrznej biblioteki kryptograficznej, jeśli chcesz używać szyfrowania, takiego jak SSL/TLS/SSH.
6	6
7	7		Zobacz dokumentację na oficjalnej stronie (link poniżej), aby uzyskać więcej informacji.
8	8
9	9		## Instalacja
10	10
11	11		Instalacja może być tak prosta, jak po prostu skopiowanie wszystkich plików do katalogu aplikacji i dodanie odpowiednich modułów Synapse do klauzuli uses.
12	12
13	13		Bardziej eleganckim i zalecanym sposobem jest kompilacja pakietu laz_synapse.lpk, dzięki czemu możesz używać tych samych modułów we wszystkich swoich projektach.
14	14
15	15		Strona informacyjna pobierania/SVN Synapse: [Strona pobierania Synapse](http://www.ararat.cz/synapse/doku.php/download)
16	16
17	17		## Wsparcie i zgłaszanie błędów
18	18
19	19		Projekt Synapse posiada listę mailingową, na której udzielane jest wsparcie i można przesyłać łatki.
20	20
21	21		Raporty o błędach można również przesyłać pocztą na listę dyskusyjną.
22	22
23	23		Zobacz [strona pomocy Synapse](http://www.ararat.cz/synapse/doku.php/support)
24	24
25	25		## Obsługa SSL/TLS
26	26
27	27		Z Synapse możesz korzystać z obsługi OpenSSL, CryptLib, StreamSecII lub OpenStreamSecII SSL. Domyślnie nie jest używana obsługa SSL.
28	28
29	29		Wsparcie jest aktywowane poprzez umieszczenie wybranej nazwy modułu w sekcji uses w swoim projekcie. Musisz także umieścić plik biblioteki binarnej w ścieżce projektu (Windows) lub zainstalować go w ścieżce wyszukiwania biblioteki (Linux, macOS, FreeBSD).
30	30
31	31		Synapse ładuje pliki bibliotek SSL w środowisku wykonawczym jako biblioteki dynamiczne.
32	32
33	33		- Szczegółowe informacje można znaleźć na stronie [Architektura wtyczek SSL/TLS](http://www.ararat.cz/synapse/doku.php/public:howto:sslplugin)
34	34		- Niektóre biblioteki kryptograficzne można uzyskać pod adresem: <http://synapse.ararat.cz/files/crypt/>
35	35
36	36		### Brakująca biblioteka
37	37
38	38		W systemie Linux musisz upewnić się, że wymagana biblioteka dynamiczna jest obecna/zainstalowana w twoim systemie. Jeśli biblioteki nie ma w systemie, to w przypadku cryptlib, podczas linkowania pojawia się komunikat o błędzie:
39	39
40		-	~~`/usr/bin/ld: cannot find -lcl`~~
	40	+	```text
	41	+	/usr/bin/ld: cannot find -lcl
	42	+	```
41	43
42	44		Podobny komunikat zostanie wyświetlony podczas korzystania z innych bibliotek dynamicznych.
43	45
44	46		## Przykład serwera WWW
45	47
46	48		Zobacz ten [[Networking\|przykład serwera internetowego (www)]].
47	49
48	50		## Przykład zapytania serwera QOTD
49	51
50	52		Zobacz ten [[QOTD\|przykład zapytania serwera - Cytat dnia]].
51	53
52	54		## Wysyłanie email
53	55
54	56		Artykuł opisujący wysyłanie e-maili wraz z załącznikami za pomocą Synapse: <http://www.freepascal.org/~michael/articles/lazmail/lazmail-en.pdf>
55	57
56	58		Przykład z [postu na forum](http://forum.lazarus.freepascal.org/index.php/topic,21157.msg123501.html#msg123501); współpracuje np. z Gmailem (czy to jest aktualne?):
57	59
58	60		``` pascal
59	61		{Ten kod obsługuje szyfrowanie TLS/SSL; jeśli wysyłasz do portu 25, SMTP używa zwykłego tekstu.}
60	62
61	63		uses
62	64		..., smtpsend,ssl_openssl; //prawdopodobnie można użyć również inne moduły SSL.
63	65
64	66		// MailData to tekst wiadomości.
65	67		function SendMail(
66	68		User, Password,
67	69		MailFrom, MailTo,
68	70		SMTPHost, SMTPPort: string;
69	71		MailData: string): Boolean;
70	72		var
71	73		SMTP: TSMTPSend;
72	74		sl:TStringList;
73	75		begin
74	76		Result:=False;
75	77		SMTP:=TSMTPSend.Create;
76	78		sl:=TStringList.Create;
77	79		try
78	80		sl.text:=Maildata;
79	81		SMTP.UserName:=User;
80	82		SMTP.Password:=Password;
81	83		SMTP.TargetHost:=SMTPHost;
82	84		SMTP.TargetPort:=SMTPPort;
83	85		SMTP.AutoTLS:=true;
84	86		if Trim(SMTPPort)<>'25' then
85	87		SMTP.FullSSL:=true; // jeśli wysyłasz na port 25, nie używaj szyfrowania
86	88		if SMTP.Login then
87	89		begin
88	90		result:=SMTP.MailFrom(MailFrom, Length(MailData)) and
89	91		SMTP.MailTo(MailTo) and
90	92		SMTP.MailData(sl);
91	93		SMTP.Logout;
92	94		end;
93	95		finally
94	96		SMTP.Free;
95	97		sl.Free;
96	98		end;
97	99		end;
98	100		```
99	101
100	102		### Wysyłanie załączników
101	103
102	104		Proszę zapoznać się z tą [dokumentacją Synapse](http://synapse.ararat.cz/doku.php/public:howto:tmimepart).
103	105
104	106		## Pobieranie plików
105	107
106	108		### Z serwera FTP
107	109
108	110		Po podaniu adresu URL (i ścieżki) oraz nazwy pliku, zostanie on pobrany z serwera FTP. Jest to głównie opakowanie wokół kodu Synapse, które ma ułatwić pobieranie dowolnych plików. Jeśli dokładnie wiesz, co i gdzie chcesz pobrać, wystarczy wywołać Synapse:
109	111
110	112		``` pascal
111	113		FtpGetFile
112	114		```
113	115
114	116		zaprowadzi cię bardzo daleko.
115	117
116	118		``` pascal
117	119		function DownloadFTP(URL, TargetFile: string): boolean;
118	120		const
119	121		FTPPort=21;
120	122		FTPScheme='ftp://'; //Nazwa schematu URI dla adresów URL FTP
121	123		var
122	124		Host: string;
123	125		Port: integer;
124	126		Source: string;
125	127		FoundPos: integer;
126	128		begin
127	129		// Usuń informacje o schemacie:
128	130		if LeftStr(URL, length(FTPScheme))=FTPScheme then URL:=Copy(URL, length(FTPScheme)+1, length(URL));
129	131
130	132		// Surowa analiza; można użyć kodu parsującego URI z pakietów FPC...
131	133		FoundPos:=pos('/', URL);
132	134		Host:=LeftStr(URL, FoundPos-1);
133	135		Source:=Copy(URL, FoundPos+1, Length(URL));
134	136
135	137		//Sprawdź numery portów:
136	138		FoundPos:=pos(':', Host);
137	139		Port:=FTPPort;
138	140		if FoundPos>0 then
139	141		begin
140	142		Host:=LeftStr(Host, FoundPos-1);
141	143		Port:=StrToIntDef(Copy(Host, FoundPos+1, Length(Host)),21);
142	144		end;
143	145		Result:=FtpGetFile(Host, IntToStr(Port), Source, TargetFile, 'anonymous', 'fpc@example.com');
144	146		if result=false then writeln('DownloadFTP: error downloading '+URL+'. Details: host: '+Host+'; port: '+Inttostr(Port)+'; remote path: '+Source+' to '+TargetFile);
145	147		end;
146	148		```
147	149
148	150		Przykład pobrania listy plików dostępnych w podanej ścieżce
149	151
150	152		``` pascal
151	153		//Użyj modułu ftpsend
152	154
153	155		function FtpGetDir(const IP, Port, Path, User, Pass: string; DirList: TStringList): Boolean;
154	156		var
155	157		i: Integer;
156	158		s: string;
157	159		begin
158	160		Result := False;
159	161		with TFTPSend.Create do
160	162		try
161	163		Username := User;
162	164		Password := Pass;
163	165		TargetHost := IP;
164	166		TargetPort := Port;
165	167		if not Login then
166	168		Exit;
167	169		Result := List(Path, False);
168	170		for i := 0 to FtpList.Count -1 do
169	171		begin
170	172		s := FTPList[i].FileName;
171	173		DirList.Add(s);
172	174		end;
173	175		Logout;
174	176		finally
175	177		Free;
176	178		end;
177	179		end;
178	180		```
179	181
180	182		### Z serwera HTTP
181	183
182	184		Po podaniu adresu URL (i ścieżki) oraz nazwy pliku, zostanie on pobrany z serwera HTTP. Zauważ, że ten kod sprawdza kod statusu HTTP (np. 200, 404), aby sprawdzić, czy dokument, który otrzymaliśmy z serwera, jest żądanym plikiem czy stroną błędu.
183	185
184	186		#### Wersja prosta
185	187
186	188		``` pascal
187	189		...
188	190		uses httpsend,
189	191		...
190	192		function DownloadHTTP(URL, TargetFile: string): Boolean;
191	193		var
192	194		HTTPGetResult: Boolean;
193	195		HTTPSender: THTTPSend;
194	196		begin
195	197		Result := False;
196	198		HTTPSender := THTTPSend.Create;
197	199		try
198	200		HTTPGetResult := HTTPSender.HTTPMethod('GET', URL);
199	201		if (HTTPSender.ResultCode >= 100) and (HTTPSender.ResultCode<=299) then begin
200	202		HTTPSender.Document.SaveToFile(TargetFile);
201	203		Result := True;
202	204		end;
203	205		finally
204	206		HTTPSender.Free;
205	207		end;
206	208		end;
207	209		```
208	210
209	211		#### Wersja zaawansowana
210	212
211	213		``` pascal
212	214		...
213	215		uses httpsend
214	216		...
215	217		function DownloadHTTP(URL, TargetFile: string): Boolean;
216	218		// Pobieranie pliku; w razie potrzeby spróbuj ponownie.
217	219		// Można próbować użyć funkcji Synapse HttpGetBinary, ale to nie działa
218	220		// z kodami wyników (tzn. szczęśliwie pobiera dokument błędu 404)
219	221		const
220	222		MaxRetries = 3;
221	223		var
222	224		HTTPGetResult: Boolean;
223	225		HTTPSender: THTTPSend;
224	226		RetryAttempt: Integer;
225	227		begin
226	228		Result := False;
227	229		RetryAttempt := 1;
228	230		HTTPSender := THTTPSend.Create;
229	231		try
230	232		try
231	233		// Spróbuj pobrać plik
232	234		HTTPGetResult := HTTPSender.HTTPMethod('GET', URL);
233	235		while (HTTPGetResult = False) and (RetryAttempt < MaxRetries) do
234	236		begin
235	237		Sleep(500 * RetryAttempt);
236	238		HTTPSender.Clear;
237	239		HTTPGetResult := HTTPSender.HTTPMethod('GET', URL);
238	240		RetryAttempt := RetryAttempt + 1;
239	241		end;
240	242		// Jeśli mamy odpowiedź z serwera, sprawdź, czy plik został do nas wysłany.
241	243		case HTTPSender.Resultcode of
242	244		100..299:
243	245		begin
244	246		HTTPSender.Document.SaveToFile(TargetFile);
245	247		Result := True;
246	248		end; //informational, success
247	249		300..399: Result := False; // przekierowanie. Nie zaimplementowano, ale może się zdarzyć.
248	250		400..499: Result := False; // błąd klienta; 404 nie znaleziono itp.
249	251		500..599: Result := False; // wewnętrzny błąd serwera
250	252		else Result := False; // kod nieznany
251	253		end;
252	254		except
253	255		// Nie obchodzi nas przyczyna tego błędu; pobieranie nie powiodło się.
254	256		Result := False;
255	257		end;
256	258		finally
257	259		HTTPSender.Free;
258	260		end;
259	261		end;
260	262		```
261	263
262	264		#### Prosta wersja z paskiem postępu
263	265
264	266		Poniższy przykład pokazuje, jak uzyskać informacje o postępie z pobierania HTTP, a także rozmiar pliku. Rozmiar pliku jest pobierany z informacji zawartej w nagłówku.
265	267
266	268		> Note: Wcześniejsze wersje free pascala wymagały użycia trybu {\$mode Delphi} do poprawnego działania poniższych przykładów. Obecnie bez problemu można używać trybu {\$mode objfpc}{\$H+}. Testowane na wersji FPC:3.2.2, Lazarus:2.0.12
267	269
268	270		``` pascal
269	271		unit uhttpdownloader;
270	272
271	273		{$mode objfpc}{$H+}
272	274
273	275		interface
274	276
275	277		uses
276	278		Classes, SysUtils, httpsend, blcksock, typinfo;
277	279
278	280		type
279	281		IProgress = interface
280	282		procedure ProgressNotification(Text: String; CurrentProgress : integer; MaxProgress : integer);
281	283		end;
282	284
283	285		type
284	286		{ THttpDownloader }
285	287
286	288		THttpDownloader = class
287	289		public
288	290		function DownloadHTTP(URL, TargetFile: string; ProgressMonitor : IProgress): Boolean;
289	291		private
290	292		Bytes : Integer;
291	293		MaxBytes : Integer;
292	294		HTTPSender: THTTPSend;
293	295		ProgressMonitor : IProgress;
294	296		procedure Status(Sender: TObject; Reason: THookSocketReason; const Value: String);
295	297		function GetSizeFromHeader(Header: String):integer;
296	298		end;
297	299
298	300		implementation
299	301
300	302		function THttpDownloader.DownloadHTTP(URL, TargetFile: string; ProgressMonitor : IProgress): Boolean;
301	303		var
302	304		HTTPGetResult: Boolean;
303	305		begin
304	306		Result := False;
305	307		Bytes:= 0;
306	308		MaxBytes:= -1;
307	309		Self.ProgressMonitor:= ProgressMonitor;
308	310
309	311		HTTPSender := THTTPSend.Create;
310	312		try
311	313		HTTPSender.Sock.OnStatus:= Status;
312	314		HTTPGetResult := HTTPSender.HTTPMethod('GET', URL);
313	315		if (HTTPSender.ResultCode >= 100) and (HTTPSender.ResultCode<=299) then begin
314	316		HTTPSender.Document.SaveToFile(TargetFile);
315	317		Result := True;
316	318		end;
317	319		finally
318	320		HTTPSender.Free;
319	321		end;
320	322		end;
321	323
322	324		procedure THttpDownloader.Status(Sender: TObject; Reason: THookSocketReason; const Value: String);
323	325		var
324	326		V, currentHeader: String;
325	327		i: integer;
326	328		begin
327	329		//spróbuj pobrać rozmiar pliku z nagłówków
328	330		if (MaxBytes = -1) then
329	331		begin
330	332		for i:= 0 to HTTPSender.Headers.Count - 1 do
331	333		begin
332	334		currentHeader:= HTTPSender.Headers[i];
333	335		MaxBytes:= GetSizeFromHeader(currentHeader);
334	336		if MaxBytes <> -1 then break;
335	337		end;
336	338		end;
337	339
338	340		V := GetEnumName(TypeInfo(THookSocketReason), Integer(Reason)) + ' ' + Value;
339	341
340	342		if Reason = THookSocketReason.HR_ReadCount then
341	343		begin
342	344		Bytes:= Bytes + StrToInt(Value);
343	345		ProgressMonitor.ProgressNotification(V, Bytes, MaxBytes);
344	346		end;
345	347		end;
346	348
347	349		function THttpDownloader.GetSizeFromHeader(Header: String): integer;
348	350		var
349	351		item : TStringList;
350	352		begin
351	353		Result:= -1;
352	354
353	355		if Pos('Content-Length:', Header) <> 0 then
354	356		begin
355	357		item:= TStringList.Create();
356	358		item.Delimiter:= ':';
357	359		item.StrictDelimiter:=true;
358	360		item.DelimitedText:=Header;
359	361		if item.Count = 2 then
360	362		begin
361	363		Result:= StrToInt(Trim(item[1]));
362	364		end;
363	365		end;
364	366		end;
365	367
366	368		end.
367	369		```
368	370
369	371		Co my tu robimy?
370	372
371	373		Przede wszystkim zaglądamy do nagłówków, aby uzyskać rozmiar pliku. Musimy poczekać i sprawdzić, czy nagłówek tam jest. Pierwsze zdarzenia nie zawierają informacji o treści Content-Length.
372	374
373	375		Po znalezieniu wyodrębniamy te informacje. Pojawia się tutaj kilka zdarzeń, na które możesz zareagować. Ale w tym przykładzie sprawdzamy tylko THookSocketReason.HR_ReadCount.
374	376
375	377		„HR_ReadCount” dostarcza nam informacji ile bajtów zostało odczytanych od ostatniego zdarzenia.
376	378
377	379		Postęp jest następnie zgłaszany do interfejsu użytkownika:
378	380
379	381		``` pascal
380	382		procedure TMainForm.ProgressNotification(Text: String; CurrentProgress: integer; MaxProgress: integer);
381	383		begin
382	384		if (MaxProgress <> -1) then
383	385		begin
384	386		ProgressBar.Max:= MaxProgress;
385	387		end;
386	388
387	389		ProgressBar.Position:= CurrentProgress;
388	390		memoStatus.Lines.Add(Text);
389	391		Application.ProcessMessages;
390	392		end;
391	393		```
392	394
393	395		Tak więc ostatecznym głównym modułem będzie:
394	396
395	397		``` pascal
396	398		unit uMain;
397	399
398	400		{$mode objfpc}{$H+}
399	401
400	402		interface
401	403
402	404		uses
403	405		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, ComCtrls, httpsend, blcksock, typinfo,
404	406		uhttpdownloader;
405	407
406	408		type
407	409
408	410		{ TMainForm }
409	411
410	412		TMainForm = class(TForm, IProgress)
411	413		btnStartDownload: TButton;
412	414		edtUrl: TEdit;
413	415		labelUrl: TLabel;
414	416		memoStatus: TMemo;
415	417		ProgressBar: TProgressBar;
416	418		SaveDialog: TSaveDialog;
417	419		procedure btnStartDownloadClick(Sender: TObject);
418	420		private
419	421		{ private declarations }
420	422		function GetFileNameFromURL(url: String):string;
421	423		public
422	424		{ public declarations }
423	425		procedure ProgressNotification(Text: String; CurrentProgress : integer; MaxProgress : integer);
424	426		end;
425	427
426	428		var
427	429		MainForm: TMainForm;
428	430
429	431		implementation
430	432
431	433		{$R *.lfm}
432	434
433	435		{ TMainForm }
434	436
435	437		procedure TMainForm.btnStartDownloadClick(Sender: TObject);
436	438		var
437	439		fileName: String;
438	440		downloader: THttpDownloader;
439	441		success: boolean;
440	442		begin
441	443		fileName:= GetFileNameFromURL(edtUrl.Text);
442	444		SaveDialog.FileName:=fileName;
443	445		if (SaveDialog.Execute) then
444	446		begin
445	447		memoStatus.Lines.Clear;
446	448		ProgressBar.Position:=0;
447	449		downloader:= THttpDownloader.Create();
448	450		success:= downloader.DownloadHTTP(edtUrl.Text, SaveDialog.FileName, Self);
449	451
450	452		ProgressBar.Position:=0;
451	453		if Success then
452	454		memoStatus.Lines.Add('Download successful')
453	455		else
454	456		memoStatus.Lines.Add('Error during download');
455	457
456	458		end;
457	459		end;
458	460
459	461		function TMainForm.GetFileNameFromURL(url: String): string;
460	462		var i, l : integer;
461	463		fileName, current : String;
462	464		begin
463	465		fileName:= '';
464	466		l:= Length(url);
465	467		for i:= l downto 0 do begin
466	468		current:= url[i];
467	469		if current <> '/' then
468	470		begin
469	471		fileName:= current + fileName;
470	472		end else begin
471	473		Result:= fileName;
472	474		break;
473	475		end;
474	476		end;
475	477		end;
476	478
477	479		procedure TMainForm.ProgressNotification(Text: String; CurrentProgress: integer; MaxProgress: integer);
478	480		begin
479	481		if (MaxProgress <> -1) then ProgressBar.Max:= MaxProgress;
480	482		ProgressBar.Position:= CurrentProgress;
481	483		memoStatus.Lines.Add(Text);
482	484		Application.ProcessMessages;
483	485		end;
484	486
485	487		end.
486	488		```
487	489
488	490		Odnosnik: <https://andydunkel.net/2015/09/09/lazarus_synapse_progress/>
489	491
490	492		#### Z serwera HTTP przez parsowanie adresów URL: Sourceforge
491	493
492	494		Zobacz [[Download from SourceForge\|Pobieranie z SourceForge]], aby zapoznać się z przykładem pobierania z sourceforge.net.
493	495
494	496		### Z serwera HTTPS
495	497
496	498		Jest to podobne do pobierania z serwera HTTP. Dodatkowo musisz [[Synapse\|aktywować obsługę SSL/TLS]] i uzyskać plik(i) binarny wymaganej biblioteki. Następnie możesz użyć tej samej funkcji DownloadHTTP do pobrania pliku z adresu URL zaczynającego się od <https://>.
497	499
498	500		## Przykładowy program klienta SSH/Telnet
499	501
500	502		Poniżej znajdziesz moduł, który pozwala na korzystanie z funkcjonalności klienta telnet/SSH, która wykorzystuje moduł synapse tlntsend.pas. Przykładowy program pokazuje, jak tego używać. Inny, prostszy sposób ilustruje Leonardo Ramé na [1](http://leonardorame.blogspot.com/2010/01/synapse-based-ssh-client.html). Jego przykład nie może jednak używać telnetu i wysyła tylko jedno polecenie.
501	503
502	504		### Wymagania
503	505
504	506		Oprócz źródeł Synapse (z których potrzebujesz tylko kilku), jeśli chcesz korzystać z funkcjonalności SSH, będziesz potrzebować biblioteki szyfrowania, której używa Synapse. Chyba, że używasz tylko usługi Telnet, wówczas tego nie potrzebujesz.
505	507
506	508		Istnieją 2 możliwości:
507	509
508	510		- Biblioteka Cryptlib. Zaleta: stabilna. Najwyraźniej można używać kluczy prywatnych, ale są one stosowane w pewnym formacie, który nie jest powszechnie obsługiwany.
509	511		- Biblioteka LibSSH2. Obsługa w Pascalu jest nadal w fazie rozwoju, ale do uwierzytelnienia możesz użyć pliku z kluczem prywatnym (w formacie OpenSSH).
510	512
511	513		#### Cryptlib
512	514
513	515		- W systemie Windows pobierz binarną wersję biblioteki DLL cryptlib (CL32.DLL) i umieść ją w katalogu źródłowym. Jeśli kompilujesz do innego katalogu lub rozprowadzasz swój program, będziesz musiał również rozesłać bibliotekę DLL.
514	516		- W systemach Linux i OSX zainstaluj cryptlib za pomocą menedżera pakietów lub z innych źródeł. Podczas dystrybucji aplikacji oznacz cryptlib jako wymaganie w swoim pakiecie .deb/.rpm/inny.
515	517
516	518		Będziesz także potrzebował dowiązań (cryptlib.pas), obecnych w źródłach dystrybucji cryptlib.
517	519
518	520		Wersje pliku binarnego cryptlib i dowiązania muszą być zgodne.
519	521
520	522		> Note: Wygląda na to, że cryptlib nie nadaje się do łączenia z maszynami linuksowymi, chociaż w systemie AIX działa. Zamiast tego użyj SSH2.
521	523
522	524		#### LibSSH2
523	525
524	526		- W systemie Windows pobierz binarną wersję biblioteki DLL libssh2 (LIBSSH2.DLL) i umieść ją w katalogu źródłowym. Jeśli kompilujesz do innego katalogu lub rozprowadzasz swój program, będziesz musiał również rozesłać tą bibliotekę DLL.
525	527		- W systemach Linux i macOS zainstaluj libssh2 za pomocą menedżera pakietów lub z innych środków. Ponadto dystrybuując swoją aplikację:
526	528		- Linux: oznacz libssh2 jako wymaganie w swoim pakiecie .deb/.rpm/inny.
527	529		- macOS: dołącz libssh2 do katalogu zasobów [[Application Bundle\|Pakietu aplikacji]].
528	530
529	531		Będziesz także potrzebował ssl_libssh2.pas (patrz poniżej) i dowiązań: (libssh2.pas, zobacz [ten post na forum](http://www.lazarus.freepascal.org/index.php/topic,15935.msg86465.html#msg86465)). Plik binarny libssh2 i dowiązania muszą być zgodne.
530	532
531	533		### Wtyczka Synapse libssh2 SSL
532	534
533	535		> Note: Wtyczka nie jest ukończona.
534	536
535	537		``` pascal
536	538		{
537	539		ssl_libssh2.pas wersja 0.2
538	540
539	541		Wtyczka obsługi SSH2 (zarys) dla biblioteki Synapse (http://www.ararat.cz/synapse) do LibSSH2 (http://libssh2.org)
540	542		Wymaga: interfejsu libssh2 pascal - http://www.lazarus.freepascal.org/index.php/topic,15935.msg86465.html#msg86465 oraz
541	543		libssh2.dll z OpenSSL.
542	544
543	545		(С) Alexey Suhinin http://x-alexey.narod.ru
544	546		}
545	547
546	548		{$IFDEF FPC}
547	549		{$MODE DELPHI}
548	550		{$ENDIF}
549	551		{$H+}
550	552
551	553		unit ssl_libssh2;
552	554
553	555		interface
554	556
555	557		uses
556	558		SysUtils,
557	559		blcksock, synsock,
558	560		libssh2;
559	561
560	562		type
561	563		{:@abstract(klasa implementująca wtyczkę CryptLib SSL/SSH.)
562	564		Instancja tej klasy zostanie utworzona dla każdego @link(TTCPBlockSocket).
563	565		Nie musisz tworzyć instancji tej klasy, wszystko robi sam Synapse!}
564	566		TSSLLibSSH2 = class(TCustomSSL)
565	567		protected
566	568		FSession: PLIBSSH2_SESSION;
567	569		FChannel: PLIBSSH2_CHANNEL;
568	570		function SSHCheck(Value: integer): Boolean;
569	571		function DeInit: Boolean;
570	572		public
571	573		{:Zobacz @inherited}
572	574		constructor Create(const Value: TTCPBlockSocket); override;
573	575		destructor Destroy; override;
574	576		function Connect: boolean; override;
575	577		function LibName: String; override;
576	578		function Shutdown: boolean; override;
577	579		{:Zobacz @inherited}
578	580		function BiShutdown: boolean; override;
579	581		{:Zobacz @inherited}
580	582		function SendBuffer(Buffer: TMemory; Len: Integer): Integer; override;
581	583		{:Zobacz @inherited}
582	584		function RecvBuffer(Buffer: TMemory; Len: Integer): Integer; override;
583	585		{:Zobacz @inherited}
584	586		function WaitingData: Integer; override;
585	587		{:Zobacz @inherited}
586	588		function GetSSLVersion: string; override;
587	589		published
588	590		end;
589	591
590	592		implementation
591	593
592	594		{==============================================================================}
593	595		function TSSLLibSSH2.SSHCheck(Value: integer): Boolean;
594	596		var
595	597		PLastError: PAnsiChar;
596	598		ErrMsgLen: Integer;
597	599		begin
598	600		Result := true;
599	601		FLastError := 0;
600	602		FLastErrorDesc := '';
601	603		if Value<0 then
602	604		begin
603	605		FLastError := libssh2_session_last_error(FSession, PLastError, ErrMsglen, 0);
604	606		FLastErrorDesc := PLastError;
605	607		Result := false;
606	608		end;
607	609		end;
608	610
609	611		function TSSLLibSSH2.DeInit: Boolean;
610	612		begin
611	613		if Assigned(FChannel) then
612	614		begin
613	615		libssh2_channel_free(FChannel);
614	616		FChannel := nil;
615	617		end;
616	618		if Assigned(FSession) then
617	619		begin
618	620		libssh2_session_disconnect(FSession,'Goodbye');
619	621		libssh2_session_free(FSession);
620	622		FSession := nil;
621	623		end;
622	624		FSSLEnabled := False;
623	625		Result := true;
624	626		end;
625	627
626	628		constructor TSSLLibSSH2.Create(const Value: TTCPBlockSocket);
627	629		begin
628	630		inherited Create(Value);
629	631		FSession := nil;
630	632		FChannel := nil;
631	633		end;
632	634
633	635		destructor TSSLLibSSH2.Destroy;
634	636		begin
635	637		DeInit;
636	638		inherited Destroy;
637	639		end;
638	640
639	641		function TSSLLibSSH2.Connect: boolean;
640	642		begin
641	643		Result := False;
642	644		if SSLEnabled then DeInit;
643	645		if (FSocket.Socket <> INVALID_SOCKET) and (FSocket.SSL.SSLType = LT_SSHv2) then
644	646		begin
645	647		FSession := libssh2_session_init();
646	648		if not Assigned(FSession) then
647	649		begin
648	650		FLastError := -999;
649	651		FLastErrorDesc := 'Cannot initialize SSH session';
650	652		exit;
651	653		end;
652	654		if not SSHCheck(libssh2_session_startup(FSession, FSocket.Socket)) then
653	655		exit;
654	656		if (FSocket.SSL.PrivateKeyFile<>'') then
655	657		begin
656	658		if (not SSHCheck(libssh2_userauth_publickey_fromfile(FSession, PChar(FSocket.SSL.Username), nil, PChar(FSocket.SSL.PrivateKeyFile), PChar(FSocket.SSL.KeyPassword)))) then
657	659		exit;
658	660		end
659	661		else
660	662		if (FSocket.SSL.Username<>'') and (FSocket.SSL.Password<>'') then
661	663		begin
662	664		if (not SSHCheck(libssh2_userauth_password(FSession, PChar(FSocket.SSL.Username), PChar(FSocket.SSL.Password)))) then
663	665		exit;
664	666		end;
665	667		FChannel := libssh2_channel_open_session(FSession);
666	668		if not assigned(FChannel) then
667	669		begin
668	670		SSHCheck(-1); // get error
669	671		if FLastError = 0 then
670	672		begin
671	673		FLastError := -999; // unknown error
672	674		FLastErrorDesc := 'Cannot open session';
673	675		end;
674	676		exit;
675	677		end;
676	678		if not SSHCheck(libssh2_channel_request_pty(FChannel, 'vanilla')) then
677	679		exit;
678	680		if not SSHCheck(libssh2_channel_shell(FChannel)) then
679	681		exit;
680	682		FSSLEnabled := True;
681	683		Result := True;
682	684		end;
683	685		end;
684	686
685	687		function TSSLLibSSH2.LibName: String;
686	688		begin
687	689		Result := 'ssl_libssh2';
688	690		end;
689	691
690	692		function TSSLLibSSH2.Shutdown: boolean;
691	693		begin
692	694		Result := DeInit;
693	695		end;
694	696
695	697		function TSSLLibSSH2.BiShutdown: boolean;
696	698		begin
697	699		Result := DeInit;
698	700		end;
699	701
700	702		function TSSLLibSSH2.SendBuffer(Buffer: TMemory; Len: Integer): Integer;
701	703		begin
702	704		Result:=libssh2_channel_write(FChannel, PChar(Buffer), Len);
703	705		SSHCheck(Result);
704	706		end;
705	707
706	708		function TSSLLibSSH2.RecvBuffer(Buffer: TMemory; Len: Integer): Integer;
707	709		begin
708	710		result:=libssh2_channel_read(FChannel, PChar(Buffer), Len);
709	711		SSHCheck(Result);
710	712		end;
711	713
712	714		function TSSLLibSSH2.WaitingData: Integer;
713	715		begin
714	716		if libssh2_poll_channel_read(FChannel, Result) <> 1 then Result := 0;
715	717		end;
716	718
717	719		function TSSLLibSSH2.GetSSLVersion: string;
718	720		begin
719	721		Result:=libssh2_version(0);
720	722		end;
721	723
722	724		initialization
723	725		if libssh2_init(0)=0 then
724	726		SSLImplementation := TSSLLibSSH2;
725	727
726	728		finalization
727	729		libssh2_exit;
728	730
729	731		end.
730	732		```
731	733
732	734		### Klasa klienta terminala
733	735
734	736		Poniższy moduł telnetsshclient.pas wykorzystuje moduł Synapse tlntsend.pas i opisuje logowanie, wysyłanie poleceń, odbieranie danych wyjściowych i wylogowywanie.
735	737
736	738		Jeśli potrzebujesz tylko klienta telnet i możesz żyć bez obsługi SSH, zakomentuj {\$DEFINE HAS_SSH_SUPPORT} poniżej, aby kod nie wymagał biblioteki libssh2.
737	739
738	740		To urządzenie zostało lekko przetestowane na serwerze Linux ssh/telnet. Dodatkowe testy mile widziane.
739	741
740	742		``` pascal
741	743		unit telnetsshclient;
742	744
743	745		{ Wrapper wokół bibliotek Synapse i biblioteki SSL (obecnie używane są libssh2+libssl)
744	746		Pobierz skompilowaną bibliotekę Windows dll, np. z
745	747		http://alxdm.dyndns-at-work.com:808/files/windll_libssh2.zip
746	748		Pobierz pliki interfejsu FreePascal:
747	749		http://www.lazarus.freepascal.org/index.php/topic,15935.msg86465.html#msg86465
748	750
749	751		Ten moduł umożliwia użytkownikowi wysyłanie poleceń Telnet lub SSH i uzyskiwanie danych wyjściowych
750	752		Dzięki Leonardo Rame
751	753		http://leonardorame.blogspot.com/2010/01/synapse-based-ssh-client.html
752	754		i Ludo Brands.
753	755
754	756		Napisany przez Reiniera Olislagersa 2011.
755	757		Zmodyfikowany dla libssh2 przez Alexeya Suhinina 2012.
756	758
757	759		Licencja kodu:
758	760		* MIT
759	761		* LGPLv2 lub nowszy (z wyjątkiem statycznego linkowania FreePascal)
760	762		* GPLv2 lub nowszy
761	763		zgodnie z twoim wyborem.
762	764		Dozwolone jest bezpłatne korzystanie, ale proszę nie pozywać mnie ani nie obwiniać.
763	765
764	766		Korzysta z innych bibliotek/komponentów, dla których mogą obowiązywać różne licencje, które również mogą wpływać na skompilowaną pracę.
765	767		}
766	768
767	769		{$mode objfpc}{$H+}
768	770		{$DEFINE HAS_SSH_SUPPORT} //zakomentuj, jeśli wymagana jest tylko obsługa telnet
769	771		{$DEFINE LIBSSH2}
770	772
771	773		interface
772	774
773	775		uses
774	776		Classes, SysUtils,
775	777		tlntsend
776	778		{$IFDEF HAS_SSH_SUPPORT}
777	779		{ssl - a właściwie teraz ssh - biblioteki wymagane przez tlntsend}
778	780		{$IFDEF LIBSSH2}
779	781		ssl_libssh2
780	782		{$ELSE}
781	783		ssl_cryptlib
782	784		{$ENDIF}
783	785		{$ENDIF HAS_SSH_SUPPORT} ;
784	786
785	787		type
786	788		TProtocolType = (Telnet, SSH); //Różne sposoby łączenia
787	789		TServerType = (Unix, Windows); //głównie dotyczy zakończenia linii tekstu
788	790		{ TelnetSSHClient }
789	791
790	792		{ TTelnetSSHClient }
791	793
792	794		TTelnetSSHClient = class(TTelnetSend)
793	795		protected
794	796		FConnected: boolean;
795	797		FOutputPosition: integer; //Śledzi pozycję w strumieniu wyjściowym
796	798		FProtocolType: TProtocolType;
797	799		FServerLineEnding: string; //zależy od FServerType
798	800		FServerType: TServerType;
799	801		FWelcomeMessage, FTelnetLoginPrompt, FTelnetPasswordPrompt: string;
800	802		procedure SetPrivateKeyFile(Value: string);
801	803		function GetPrivateKeyFile: string;
802	804		{ Na podstawie protokołu i typu serwera ustaw oczekiwane zakończenie linii po stronie serwera}
803	805		procedure DetermineLineEnding;
804	806		{ Ustawia port, jeśli portu nie ustawiono jawnie. Używa protokołu typu: SSH lub telnet}
805	807		procedure DeterminePort;
806	808		function GetSessionLog: string;
807	809		procedure ProtocolTypeChange(Value: TProtocolType);
808	810		function ReceiveData: string; //Może być używany do odbierania wiadomości powitalnej itp.
809	811		procedure SendData(Data: string);
810	812		procedure ServerTypeChange(Value: TServerType);
811	813		public
812	814		{Wszystkie dane wyjściowe wygenerowane podczas całej sesji do tej pory}
813	815		property AllOutput: string read GetSessionLog;
814	816		{Ma wartość True, jeśli jest podłączony do serwera}
815	817		property Connected: boolean read FConnected;
816	818		{Nazwa lub adres IP hosta, z którym chcesz się połączyć}
817	819		property HostName: string read FTargetHost write FTargetHost;
818	820		{Port na hoście używany do połączenia. Jeśli zostanie pozostawiony jako 0, zostanie określony przez typ protokołu (22 dla SSH, 23 dla Telnet}
819	821		property Port: String read FTargetPort write FTargetPort;
820	822		{Lokalizacja pliku klucza prywatnego}
821	823		property PrivateKeyFile: string read GetPrivateKeyFile write SetPrivateKeyFile;
822	824		{Pytanie o login Telnet}
823	825		property TelnetLoginPrompt: string read FTelnetLoginPrompt write FTelnetLoginPrompt;
824	826		{Pytanie o hasło Telnet}
825	827		property TelnetPasswordPrompt: string read FTelnetPasswordPrompt write FTelnetPasswordPrompt;
826	828		{Nazwa użytkownika używana podczas łączenia}
827	829		property UserName: string read FUserName write FUserName;
828	830		{Hasło używane podczas łączenia. Używane jako hasło (passphrase), jeśli używany jest klucz prywatny}
829	831		property Password: string read FPassword write FPassword;
830	832		{Czy powinniśmy rozmawiać z serwerem przez Telnet czy SSH? Domyślnie jest to SSH}
831	833		property ProtocolType: TProtocolType read FProtocolType write ProtocolTypeChange;
832	834		{Serwer Windows czy Unix/Linux? Ma to wpływ na końcówki linii. Domyślnie jest to Unix. UWAGA: nieprzetestowane}
833	835		property Servertype: TServerType read FServerType write ServerTypeChange;
834	836		{Pierwsza wiadomość wyświetlana przy logowaniu}
835	837		property WelcomeMessage: string read FWelcomeMessage;
836	838		{Połącz/zaloguj się do serwera. Wymaga poprawnych wszystkich opcji uwierzytelniania, protokołu i nazwy hosta/portu.
837	839		Zwraca opisowy wynik. Następnie możesz użyć właściwości Connected.}
838	840		function Connect: string;
839	841		{Jeśli połączony, wyloguj się z serwera}
840	842		procedure Disconnect;
841	843		{Wyślij polecenie do serwera i odbierz wynik}
842	844		function CommandResult(Command: string): string; //Wyślij polecenie i uzyskaj wyniki
843	845		constructor Create;
844	846		destructor Destroy; override;
845	847		end;
846	848
847	849		implementation
848	850
849	851
850	852		{ TelnetSSHClient }
851	853		procedure TTelnetSSHClient.SetPrivateKeyFile(value: string);
852	854		begin
853	855		Sock.SSL.PrivateKeyFile := value;
854	856		end;
855	857
856	858		function TTelnetSSHClient.GetPrivateKeyFile: string;
857	859		begin
858	860		Result := Sock.SSL.PrivateKeyFile;
859	861		end;
860	862
861	863		procedure TTelnetSSHClient.DetermineLineEnding;
862	864		begin
863	865		case FProtocolType of
864	866		SSH:
865	867		begin
866	868		if FServerType = Unix then
867	869		FServerLineEnding := #10 //Unix
868	870		else
869	871		FServerLineEnding := #13 + #10; //windows
870	872		end;
871	873		Telnet:
872	874		begin
873	875		if FServerType = Unix then
874	876		FServerLineEnding := #10 //Unix
875	877		else
876	878		FServerLineEnding := #13 + #10; //windows
877	879		end;
878	880		else
879	881		raise Exception.Create('Nieznany typ protokołu.');
880	882		end;
881	883		end;
882	884
883	885		procedure Ttelnetsshclient.DeterminePort;
884	886		begin
885	887		if FTargetPort = '' then
886	888		//Ustaw domyślny port dla protokołu
887	889		begin
888	890		case FProtocolType of
889	891		Telnet: FTargetPort := '23';
890	892		SSH: FTargetPort := '22';
891	893		else
892	894		raise Exception.Create('Nieznany typ protokołu.');
893	895		end;
894	896
895	897		end;
896	898		end;
897	899
898	900		procedure TTelnetSSHClient.ServerTypeChange(Value: Tservertype);
899	901		begin
900	902		FServerType := Value;
901	903		DetermineLineEnding;
902	904		end;
903	905
904	906		function TTelnetSSHClient.Connect: string;
905	907		var
906	908		Received: string;
907	909		begin
908	910		result:='Nieznany błąd podczas łączenia';
909	911		FOutputPosition := 1; //Pierwszy znak w strumieniu wyjściowym
910	912		FWelcomeMessage := '';
911	913		//Tylko dla pewności:
912	914		DetermineLineEnding;
913	915		DeterminePort;
914	916		if FTargetPort='0' then
915	917		begin
916	918		result:='Port nie może być równy 0.';
917	919		exit; //wyskoczyć z funkcji
918	920		end;
919	921		case FProtocolType of
920	922		Telnet:
921	923		begin
922	924		try
923	925		if Login then
924	926		begin
925	927		FConnected := True;
926	928		result:='Połączono z serwerem telnet.';
927	929		end
928	930		else
929	931		if Sock.LastError<>0 then raise Exception.Create(Sock.LastErrorDesc);
930	932		except
931	933		on E: Exception do
932	934		begin
933	935		FConnected:=false;
934	936		result:='Błąd połączenia z serwerem telnet '+FTargetHost+':'+
935	937		FTargetPort+' jako użytkownik ' + FUserName +
936	938		'. Szczegóły techniczne: '+E.Message;
937	939		end;
938	940		end;
939	941		end;
940	942		SSH:
941	943		begin
942	944		{$IFNDEF HAS_SSH_SUPPORT}
943	945		raise Exception.Create(
944	946		'Obsługa SSH nie została skompilowana do biblioteki telnetsshclient.');
945	947		{$ENDIF HAS_SSH_SUPPORT}
946	948		try
947	949		if (PrivateKeyFile <> '') and (FPassword <> '') then
948	950		Sock.SSL.KeyPassword:=FPassword;
949	951		if SSHLogin then
950	952		begin
951	953		FConnected := True;
952	954		result:='Connected to SSH server.';
953	955		end
954	956		else
955	957		begin
956	958		if Sock.LastError<>0 then raise Exception.Create(Sock.LastErrorDesc);
957	959		if Sock.SSL.LastError<0 then raise Exception.Create(Sock.SSL.LastErrorDesc);
958	960		end;
959	961		except
960	962		on E: Exception do
961	963		begin
962	964		FConnected:=false;
963	965		result:='Błąd połączenia z serwerem SSH '+FTargetHost+':'+
964	966		FTargetPort+' jako użytkownik ' + FUserName +
965	967		'. Szczegóły techniczne: '+E.Message;
966	968		end;
967	969		end;
968	970		end;
969	971		else
970	972		raise Exception.Create('Nieznany typ protokołu.');
971	973		end;
972	974		if FConnected = True then
973	975		begin
974	976		FWelcomeMessage := ReceiveData;
975	977		if FProtocolType=Telnet then
976	978		begin
977	979		//Niestety, będziemy musieli sami wyodrębnić login
978	980		//Mam nadzieję, że dotyczy to wszystkich typów serwerów.
979	981		if (AnsiPos(AnsiLowerCase(FTelnetLoginPrompt),AnsiLowerCase(FWelcomeMessage))>0) then
980	982		begin
981	983		SendData(UserName);
982	984		end;
983	985		Received:=ReceiveData;
984	986		if (AnsiPos(AnsiLowerCase(FTelnetPasswordPrompt),AnsiLowerCase(Received))>0) then
985	987		begin
986	988		SendData(Password);
987	989		end;
988	990		//Otrzymuj dodatkową wiadomość powitalną/wiadomość dnia
989	991		FWelcomeMessage:=FWelcomeMessage+LineEnding+ReceiveData;
990	992		end;
991	993		end;
992	994		end;
993	995
994	996		procedure TTelnetSSHClient.Disconnect;
995	997		begin
996	998		Logout;
997	999		FConnected := False;
998	1000		end;
999	1001
1000	1002		function TTelnetSSHClient.ReceiveData: string;
1001	1003		begin
1002	1004		Result := '';
1003	1005		while Sock.CanRead(1000) or (Sock.WaitingData > 0) do
1004	1006		begin
1005	1007		Sock.RecvPacket(1000);
1006	1008		Result := Result + Copy(SessionLog, FOutputPosition,
1007	1009		Length(SessionLog));
1008	1010		FOutputPosition := Length(SessionLog) + 1;
1009	1011		end;
1010	1012		end;
1011	1013
1012	1014		procedure Ttelnetsshclient.SendData(Data: String);
1013	1015		begin
1014	1016		Data := Data + FServerLineEnding; //Może to być linux, może być Windows
1015	1017		Send(Data);
1016	1018		end;
1017	1019
1018	1020		function TTelnetSSHClient.GetSessionLog: string;
1019	1021		begin
1020	1022		// Do tej pory uzyskuje pełne dane wyjściowe
1021	1023		Result := SessionLog;
1022	1024		end;
1023	1025
1024	1026		procedure TTelnetSSHClient.ProtocolTypeChange(Value: Tprotocoltype);
1025	1027		begin
1026	1028		FProtocolType := Value;
1027	1029		//W razie potrzeby automatycznie określ port i zakończenie linii
1028	1030		DeterminePort;
1029	1031		DetermineLineEnding;
1030	1032		end;
1031	1033
1032	1034		function TTelnetSSHClient.CommandResult(Command: string): string;
1033	1035		begin
1034	1036		Result := '';
1035	1037		if FConnected then
1036	1038		begin
1037	1039		SendData(Command);
1038	1040		Result := ReceiveData; //dostaje za dużo
1039	1041		end
1040	1042		else
1041	1043		begin
1042	1044		//podnieś wyjątek
1043	1045		Result := '';
1044	1046		raise Exception.Create('Polecenie można uruchomić tylko po podłączeniu');
1045	1047		end;
1046	1048		end;
1047	1049
1048	1050		constructor TTelnetSSHClient.Create;
1049	1051		begin
1050	1052		inherited;
1051	1053		FConnected := False;
1052	1054		FProtocolType := SSH; //Może to też być telnet
1053	1055		FServerType := Unix; //Prawdopodobnie bezpieczna wartość domyślna.
1054	1056		FTelnetLoginPrompt := 'login:';
1055	1057		FTelnetPasswordPrompt := 'password:';
1056	1058		DetermineLineEnding;
1057	1059		DeterminePort;
1058	1060		end;
1059	1061
1060	1062		destructor TTelnetSSHClient.Destroy;
1061	1063		begin
1062	1064		if FConnected then
1063	1065		Disconnect;
1064	1066		inherited Destroy;
1065	1067		end;
1066	1068
1067	1069		end.
1068	1070		```
1069	1071
1070	1072		### Przykładowy kod klienta
1071	1073
1072	1074		Aby użyć właśnie stworzonej przez nas klasy TTelnetSSHClient, możesz wypróbować przykładową aplikację, sshtest.lpr. Zauważ, że kod musi być skompilowany przez Lazarusa, ponieważ potrzebuje komponentów LCL do pracy z Synapse:
1073	1075
1074	1076		``` pascal
1075	1077		program sshtest;
1076	1078
1077	1079		{Program testowy dla telnetsshclient
1078	1080
1079	1081		Napisany przez Reiniera Olislagersa 2011.
1080	1082		Zmodyfikowany dla libssh2 przez Alexeya Suhinina 2012.
1081	1083
1082	1084		Licencja kodu:
1083	1085		* MIT
1084	1086		* LGPLv2 lub nowszy (z wyjątkiem statycznego linkowania FreePascal)
1085	1087		* GPLv2 lub nowszy
1086	1088		zgodnie z twoim wyborem.
1087	1089		Dozwolone jest bezpłatne korzystanie, ale proszę nie pozywać mnie ani nie obwiniać.
1088	1090
1089	1091		Korzysta z innych bibliotek/komponentów, dla których mogą obowiązywać różne licencje, które również mogą wpływać na skompilowaną pracę.
1090	1092
1091	1093		Uruchamianie: sshtest <serverIPorhostname> [PrivateKeyFile]
1092	1094		}
1093	1095		{$mode objfpc}{$H+}
1094	1096		{$APPTYPE CONSOLE}
1095	1097
1096	1098		uses
1097	1099		telnetsshclient;
1098	1100		var
1099	1101		comm: TTelnetSSHClient;
1100	1102		Command: string;
1101	1103		begin
1102	1104		writeln('Start.');
1103	1105		comm:=TTelnetSSHClient.Create;
1104	1106		comm.HostName:= ParamStr(1); //Pierwszy argument w wierszu poleceń
1105	1107		if comm.HostName='' then
1106	1108		begin
1107	1109		writeln('Proszę podać nazwę hosta w wierszu poleceń.');
1108	1110		halt(1);
1109	1111		end;
1110	1112
1111	1113		comm.PrivateKeyFile := ParamStr(2);
1112	1114
1113	1115		comm.TargetPort:='0'; //automatyczne określanie na podstawie typu protokołu
1114	1116		comm.UserName:='root'; //zmień dla swojej sytuacji
1115	1117		comm.Password:='password'; //zmień dla swojej sytuacji
1116	1118		comm.ProtocolType:=SSH; //Telnet lub SSH
1117	1119		writeln(comm.Connect); //Pokaż wynik połączenia
1118	1120		if comm.Connected then
1119	1121		begin
1120	1122		writeln('Serwer: ' + comm.HostName + ':'+comm.TargetPort+', użytkownik: '+comm.UserName);
1121	1123		writeln('Wiadomość powitalna:');
1122	1124		writeln(comm.WelcomeMessage);
1123	1125		Command:='ls -al';
1124	1126		writeln('*** Wysyłanie ' + Command);
1125	1127		writeln('* Początek wyniku**');
1126	1128		writeln(comm.CommandResult(Command));
1127	1129		writeln('* Koniec wyniku**');
1128	1130		writeln('');
1129	1131		writeln('');
1130	1132		Command:='df -h';
1131	1133		writeln('*** Wysyłanie ' + Command);
1132	1134		writeln('* Początek wyniku**');
1133	1135		writeln(comm.CommandResult(Command));
1134	1136		writeln('* Koniec wyniku**');
1135	1137		writeln('');
1136	1138		writeln('');
1137	1139		writeln('Wszystkie wyjścia:');
1138	1140		writeln('* Początek wyniku**');
1139	1141		writeln(comm.AllOutput);
1140	1142		writeln('* Koniec wyniku**');
1141	1143		comm.Disconnect;
1142	1144		end
1143	1145		else
1144	1146		begin
1145	1147		writeln('Połączenie z ' +
1146	1148		comm.HostName + ':' +
1147	1149		comm.TargetPort + ' nie udało się.');
1148	1150		end;
1149	1151		comm.Free;
1150	1152		end.
1151	1153		```
1152	1154
1153	1155		## Integracja z OAuth v1/Twitter/Plurk
1154	1156
1155	1157		Biblioteka OAuth v1 napisana w FPC, która używa Synapse (i jest gotowa do obsługi innych bibliotek sieciowych, takich jak lNet) jest dostępna w [[fpctwit]]. FPCtwit zawiera również przykładowe programy klienckie FPC jak Twitter i Plurk oraz klienta Lazarus Twitter.
1156	1158
1157	1159		## Inne artykuły internetowe i sieciowe
1158	1160
1159	1161		- [[Portal:Web Development\|Portal na temat tworzenia stron internetowych]]
1160	1162		- [[Networking/pl\|Sieć]]
1161	1163		- [[Networking libraries/pl\|Biblioteki sieciowe]] - porównanie różnych bibliotek sieciowych
1162	1164		- [[Brook Framework]] - Idealny framework Free Pascal dla Twoich aplikacji internetowych. To czysty Pascal. Nie musisz porzucać preferowanego języka programowania.
1163	1165		- [[Sockets\|Gniazda]] - Komponenty gniazd TCP/IP
1164	1166		- [[fcl-net]] - Biblioteka sieciowa dostarczana z FPC
1165	1167		- [[lNet]] - Lekkie komponenty sieciowe
1166	1168		- [[Synapse/pl\|Synapse]] - Port szeregowy i synchroniczna biblioteka TCP/IP
1167	1169		- [[XML Tutorial\|Poradnik XML]] - XML jest często używany w komunikacji sieciowej
1168	1170		- [[FPC and Apache Modules\|FPC i moduły Apache]]
1169	1171		- [[fcl-web]] - Znana również jako fpWeb, jest to biblioteka do tworzenia aplikacji internetowych, które można wdrażać jako moduły cgi, fastcgi lub apache.
1170	1172		- [[Secure programming\|Bezpieczne programowanie]]
1171	1173		- [[Internet Tools\|Narzędzia internetowe]] - Wrapper wokół komponentów http Synapse/wininet/Android upraszczający korzystanie z https i przekierowań oraz silnik XPath/XQuery/CSS Selector/JSONiq do przetwarzania pobranych stron
1172	1174
1173	1175		## Zobacz też
1174	1176
1175	1177		- [[Download from SourceForge/pl\|Pobieranie z SourceForge]] Przykład, który używa Synapse do pobierania z serwera HTTP, który stosuje przekierowanie.
1176	1178		- [Wizualny Synapse](https://sourceforge.net/projects/visualsynapse/) wrappery komponentów dla wielu elementów komunikacji szeregowej i sieciowej biblioteki Synapse (TvsComPort, TvsWebClient, TvsSniffer, TvsHTTPServer, TvsFTPServer, TvsAuthentication, TvsVisualDNS, TvsVisualHTTP, TvsVisualDUP, TvsVisualTCP, TvsVisualICMP, TvsSocksProxyInfo, TvsIPHelper, TvsSendMail i TvsSynPing).
1177	1179		- [Komponent TCP/IP oparty na Synapse + mała aplikacja demonstracyjna](https://forum.lazarus.freepascal.org/index.php/topic,48677.0.html)
1178	1180
1179	1181		## Linki zewnętrzne
1180	1182
1181	1183		- [Oficjalna strona](http://www.ararat.cz/synapse/)
1182	1184		- [Oficjalna dokumentacja](http://synapse.ararat.cz/doc/help/)
1183	1185		- [Użytkownik malcome stworzył rozwidlenie, aby szybciej poprawić synapse](http://lazarus.freepascal.org/index.php/topic,16032.msg87066.html#msg87066); ta gałąź znajduje się pod adresem ~~[Witryna z kodem Google dla Synapse4Lazarus](http://code.google.com/p/synapse4lazarus/)~~ (aktualnie niedostępna)
1184	1186
1185	1187		---
1186	1188		From the Free Pascal wiki, page "Synapse/pl", as it stood on 2022-07-23 after a change by Slawek, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history