Indy with Lazarus: what changed

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

Old	New		Line
1	1		Indy is an open source client/server communications library that supports TCP/UDP/RAW sockets, as well as over 100 higher level protocols including SMTP, POP3, IMAP, NNTP, HTTP, FTP, and many more
2	2
3	3		## Indy for Lazarus
4	4
5	5		A new attempt at converting Indy is being undertaken by the Indy core team. FPC developer Marco van de Voort is working with Indy core to get Indy fully working with FPC/Lazarus. Specially Indy's JP Mugaas did a lot of good work in getting Indy10 to work with FPC. The native unixrtl backend is mostly his work too.
6	6
7	7		Currently Indy10 is nearly fully working, and end-user usability has been improved a lot. Only special topics like OpenSSL and compression might need additional knowledge. 64-bit support hasn't entirely been validated either.
8	8
9	9		Hint: I'm not very interested in support the Kylix side of Indy. (anything that uses unit libc). I ported it only as step up to native Unix RTL using Indy apps.
10	10
11	11		### Requirements
12	12
13	13		FPC 2.0.4 is very close to being able to use Indy in all its facets, except for the server bug on FreeBSD/macOS (which requires 2.1.1)
14	14
15	15		Since Indy10 now works for all major targets, we focus on this version. While conversion to Indy9 might be simpler for people, keep in mind that it only works on Win32 (and theoretically could be ported to Linux/x86).
16	16
17	17		Therefore we recommend people to work with 10 as much as possible.
18	18
19	19		(For indy9, you might need to remove the overriding of TMemoryStream.SetSize method (Marcov: ???) to get telnet components working, but Indy9 hasn't been tested in a while).
20	20
21	21		The port is fairly stable, and JP Mugaas has done a great deal to improve the quality of the release, a set of makefiles inclusive.
22	22
23	23		### Downloads / Links
24	24
25	25		Current snapshots (for die hards only) are at
26	26
27	27		- Indy9:
28	28		- [Indy9, includes demos](http://www.stack.nl/~marcov/indy/indy9.zip) and
29	29		- Indy10:
30	30		- converted Indy10 demos : [converted Indy10 demos](http://www.stack.nl/~marcov/demo10.zip)
31	31		- [Indy 10 website](http://www.indyproject.org) Recently, this archive started to include demos too.
32	32
33	33		### What works, what not
34	34
35	35		Indy9:
36	36
37	37		- Windows should largely work. Lots of demos ported.
38	38		- Linux not or barely. No hope at non Linux/x86 (non-Kylix) targets.
39	39
40	40		Indy10:
41	41
42	42		- Windows and Unix: clients work and servers should work fine in principle.
43	43		- The main work for native Unix RTL done. Servers Clients seem to work with FreeBSD and OS X
44	44
45	45		All: secure versions not tested yet.
46	46
47	47		### Short term plans
48	48
49	49		- Convert demos to demonstrate/test workings.
50	50		- Fix bugs and enter them back into FPC or Indy RCS.
51	51
52	52		### Problems
53	53
54	54		- Indy9 and Indy10 are mutually exclusive, which causes problems for deployment, even the default is a problem:
55	55		- Indy9 is more used and proven in the industry.
56	56		- Indy10 is more portable, and better long term. However uptake seems to be low, and there is not much movement at Indy anymore.
57	57		- How to deploy? Parts belong to Lazarus, parts to FPC.
58	58		- Lot of pkgs and demos have paths in them. How to centrally fix them so that inexperienced users can build them?
59	59		- Lazarus problems
60	60		- Transparency problems of icons
61	61		- component tabs don't scroll, if you put a lot of components in one tab, they are not selectable. workaround implemented: JP Mugaas separated them into Indy clients A-M and N-Z etc. Also, meanwhile Lazarus changed to two rows of components per tab.
62	62		- Indy demos (specially Indy10's) are not very suitable for multiplatform usage. Their setup is awfully windows specific, with spaces in paths, deep nested dirs, and useless baggage (C# code). A short working set of demos will have to be created.
63	63
64	64		### Bugs
65	65
66	66		- Indy10 servers didn't work before due to an exception occurring during startup, which shut everything down. You need FPC 2.2(.0) or later to fix this (pthread_kill problem). This probably also affects Mac OS X.
67	67
68	68		- During demo conversion, the bindings property is often wrongly converted. This can result in strange errors, specially because Indy seems to bind to the same port using both IPV4 and IPV6 at the same time.
69	69
70	70		Ubuntu 10.04 + Lazarus 0.9.28 + Indy 10(Server Component) -\> launch & do nothing (just crash)
71	71
72	72		Solution (bruce0829@yahoo.com.tw collect and organize data):
73	73
74	74		(1).Lazarus Main menu -\> Project -\> Compiler Options -\> Other Page , add the "-dUseCThreads" parameter. (2).force the IdTCPServer to work in Id_IPV4 mode.
75	75
76	76		``` pascal
77	77		procedure TForm1.FormActivate(Sender: TObject);
78	78		var
79	79		Binding: TIdSocketHandle;
80	80		begin
81	81		//uses idGlobal
82	82		//explicitly adding a Binding object prevents TIdTCPServer
83	83		//from creating its own default IPv4 and IPv6 Binding objects
84	84		//on the same listening IP/Port pair...
85	85		Binding := IdTCPServer1.Bindings.Add;
86	86		Binding.IPVersion := Id_IPv4; //optional: forces the Binding to work in Id_IPV4 mode.
87	87		Binding.IP := '127.0.0.1';
88	88		Binding.Port := 6501; //customization
89	89		IdTCPServer1.Active := True;
90	90		end;
91	91		```
92	92
93	93		(3)use TIdSync to Control your GUI in IdTCPServer's OnExecute() event.
94	94
95	95		## Installation
96	96
97	97		### How to install
98	98
99	99		Comment from RLebeau: Indy is available in [[Online Package Manager]].
100	100
101	101		Comment from Matthijs: So it is not perfect yet, but you want to try it. Here is how you install it in Lazarus.
102	102
103	103		- Open and compile indysystemlaz.lpk
104	104		- Open and compile indycorelaz.lpk
105	105		- Open and compile indyprotocolslaz.lpk
106	106		- Open, compile and install dclindycorelaz.lpk
107	107		- Open, compile and install dclindyprotocolslaz.lpk
108	108
109	109		Then rebuild Lazarus and you will see a 15 tab's with Indy components.
110	110
111	111		### How to install on Debian/Ubuntu
112	112
113	113		Commands in Terminal:
114	114
115		-	~~`cd indy-10.2.0.1/fpc`\~~
116		-	~~`chmod +x debian/rules`\~~
117		-	~~`touch README`\~~
118		-	~~`sudo apt-get install fakeroot`\~~
119		-	~~`dpkg-buildpackage -rfakeroot -uc`\~~
120		-	~~`cd ..`\~~
121		-	~~`sudo dpkg -i *.deb`~~
	115	+	```text
	116	+	cd indy-10.2.0.1/fpc
	117	+	chmod +x debian/rules
	118	+	touch README
	119	+	sudo apt-get install fakeroot
	120	+	dpkg-buildpackage -rfakeroot -uc
	121	+	cd ..
	122	+	sudo dpkg -i *.deb
	123	+	```
122	124
123	125		Then install the package indylaz.lpk in Lazarus.
124	126
125	127		### How to install \[2\]
126	128
127	129		If you couldn't install Indy for Lazarus with tips above, you can try this...
128	130
129	131		From [Yahoo! Brazil, Lazarus Group](http://br.groups.yahoo.com/group/lazarus-brasil/) (User Everaldo)
130	132
131	133		Version installed on Lazarus 0.9.24 using component indy-10.2.0.1.
132	134
133	135		- Unzip the component from file tar.gz (must be this file, the "zip file" does not work) in directory \$(LazarusDir)\components;
134	136		- Go to directory \$(LazarusDir)\components\indy-10.2.0.1\\ and to create inside them a directory named "saved";
135	137		- Copy the content of the directory \$(LazarusDir)\components\indy-10.2.0.1\lazarus\\ to directory "saved" created above;
136	138		- Copy the content of directory \$(LazarusDir)\components\indy-10.2.0.1\fpc\\ to directory \$(LazarusDir)\components\indy-10.2.0.1\lazarus, and rewrite all files, ok;
137	139		- Get the content of directory "saved" and copy inside of \$(LazarusDir)\components\indy-10.2.0.1\lazarus and you can delete "saved" directory now;
138	140		- Install the package laz.lpk (available in \$(LazarusDir)\components\indy-10.2.0.1\lazarus\indy) of conventional way.
139	141
140	142		On LINUX the path is: /usr/lib/lazarus/components/indy-10.2.0.1/
141	143
142	144		### How to install on Windows and Debian Linux, Indy 10.5 and above
143	145
144	146		- Need working Lazarus (and FPC) for this
145	147		- Download from <http://www.indyproject.org/Sockets/Download/DevSnapshot.EN.aspx>. Or from the alternate web site for the updated and current versions: <http://indy.fulgan.com/>
146	148		- unpack into a directory
147	149		- copy the .pas, .lrs and *.inc of the \Lib\System, \Lib\Core, and \Lib\Protocols subdirectories into a new directory of your choosing
148	150		- copy the indylaz.lpk in the \Lib directory to the directory you created above
149	151		- from within Lazarus do a Package -\> Open package file, open the indylaz.lpk
150	152		- in the Package Options dialog, add the path to the directory you created above to the "Unit" field.
151	153		- compile then install (will rebuild Lazarus). EDIT: Currently, due to a know bug in FPC, you must compile the Indy package TWICE before installing it.
152	154
153	155		In order to write & compile Indy10 applications, you need to put the path to the Indy directory in the "Other Unit files" textbox of every project that you write. You'll find "Other Unit files" under Project Options -\> Compiler Options -\> Paths.
154	156
155	157		### How to install (confirmed) on Windows - Indy 10.2
156	158
157	159		For a lot of users, I'm sure that the information given above won't work, or will be somewhat confusing given the differences between versions and inconsistent explanations.
158	160
159	161		The website points you to download the latest version from the snapshots page. This wiki tells you to copy a lot of files over into directories. For me, neither worked, and ended up making a mess of my Lazarus installations.
160	162
161	163		1. Firstly, the page I would retrieve this from is [here](http://www.indyproject.org/Sockets/fpc/index.EN.aspx). Other sites I tried had problems with some files inside the archive.
162	164		2. When you open up the archive above, you will see there are folders: "fpc" and "lazarus".
163	165		1. You can copy the contents of "fpc" into: LAZARUS_DIR\fpc\2.6.0\source\packages\indylaz if you want to have things neat and tidy.
164	166		2. The "lazarus" folder, you copy into LAZARUS_DIR\components\indylaz
165	167		3. With both of these, make sure that there isn't a sub-directory inside the folders given. i.e. LAZARUS_DIR\components\indylaz\lazarus\\
166	168		3. Go into Lazarus and go to "Package" -\> "Open package file" and point it to the "indylaz.lpk" inside the LAZARUS_DIR\components\indylaz directory.
167	169		4. Once the package loads inside your project, click on the "options" button, which resembles an image of a parcel with a cog next to it.
168	170		5. Click the "Compiler Options" on the left-hand side and Click on the ".." button next to "Other unit files (-Fu) (delimiter is semicolon)".
169	171
170	172		Select the "fpc" then "lazarus" folders you created above and click OK. Lazarus will sort out the relative path for you. Don't change it.
171	173
172	174		1. Click OK and compile and then direct angry bile towards the individual who has steered you wrong with the previous, unhelpful, instructions.
173	175
174	176		### Issue on Windows 64 bits
175	177
176	178		On Windows 64 bits, the compilation of the archive mentioned above will not work. This can be fixed by editing IdAntiFreeze.pas, replacing:
177	179
178	180		``` pascal
179	181		type
180	182		TIdAntiFreeze = class(TIdAntiFreezeBase)
181	183		public
182	184		procedure Process; override;
183	185		end;
184	186		```
185	187
186	188		by
187	189
188	190		``` pascal
189	191		type
190	192		TIdAntiFreeze = class(TIdAntiFreezeBase)
191	193		public
192	194		{$IFDEF WIN32}
193	195		procedure Process; override;
194	196		{$ENDIF}
195	197		end;
196	198		```
197	199
198	200		## Various tips
199	201
200	202		### Memory leaking issue
201	203
202	204		If you have memory leaks in your Indy application, that is because you use IdStack or IdThread units, or components that depend on them. It is intended by design, and in Delphi the leak reports are suppressed by registering the leaks with the memory manager. This feature is not available with Free Pascal, but you can remove the deliberate memory leaks. In file IdCompilerDefines.inc you should replace this line:
203	205
204	206		``` pascal
205	207		{.$DEFINE FREE_ON_FINAL}
206	208		{$UNDEF FREE_ON_FINAL}
207	209		```
208	210
209	211		with this:
210	212
211	213		``` pascal
212	214		{$DEFINE FREE_ON_FINAL}
213	215		{.$UNDEF FREE_ON_FINAL}
214	216		```
215	217
216	218		and recompile Lazarus and Indy. Beware that IdCompilerDefines.inc exists in 5 different directories and you need to make changes in all of them.
217	219
218	220		#### Important developer note
219	221
220	222		The leaks are not a matter of not being able to free the objects (obviously, they can be, as seen when FREE_ON_FINAL is defined), but more a matter of unit dependency. The objects in question are shared with other units, and it has been noticed that sometimes units may not always be finalized in the order you are expecting, and that has been observed in the wild. So rather than freeing these objects by default, they are leaked instead, in case they are still accessed later. The leak is minor (only a few bytes), and only during unit finalization, which 9x% of the time will only be during application shutdown (unless you are using Indy in a DLL that gets unloaded dynamically during runtime).
221	223
222	224		### How to use non-blocking TCP sockets
223	225
224	226		Advice from FPC developer Marco van de Voort: Indy can be used nonblocking if you regularly check for data on source:
225	227
226	228		``` pascal
227	229		fclient.IOHandler.CheckForDataOnSource(5);
228	230		```
229	231
230	232		and then never read more than InputBuffer.Size:
231	233
232	234		``` pascal
233	235		insiz:= IOHandler.InputBuffer.Size;
234	236		IOHandler.ReadStream(strmbuf, insiz, false);
235	237		```
236	238
237	239		While Indy 10 does a lot with streams (due to its .NET heritage) you can workaround it by using a TCustomMemoryStream derivative that just points to your own buffers, with nearly no overhead.
238	240
239	241		I myself use this for a set of client-servers that do work in threads, but use events to try to reach (relatively) low latency comms.
240	242
241	243		## External links
242	244
243	245		- [The Indy Project official website](http://www.indyproject.org)
244	246
245	247		---
246	248		From the Free Pascal wiki, page "Indy with Lazarus", as it stood on 2022-08-09 after a change by Alextp, 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