Mercurial > dwindows
comparison compat.c @ 649:3e2ada9ee0ac
Switched to using reentrant version of getmntent on Linux.
The non-reentrant version seems to be very unreliable.
author | bsmith@81767d24-ef19-dc11-ae90-00e081727c95 |
---|---|
date | Sat, 19 Feb 2011 09:37:39 +0000 |
parents | f09977bc9b5c |
children | 830e1f3672b9 |
comparison
equal
deleted
inserted
replaced
648:2b260f4309bb | 649:3e2ada9ee0ac |
---|---|
118 { | 118 { |
119 long double size = 0; | 119 long double size = 0; |
120 | 120 |
121 if(mnt.mnt_mountp) | 121 if(mnt.mnt_mountp) |
122 { | 122 { |
123 statfs(mnt.mnt_mountp, &sfs, sizeof(struct statfs), 0); | 123 if(!statfs(mnt.mnt_mountp, &sfs, sizeof(struct statfs), 0)) |
124 size = (long double)((double)sfs.f_bsize * (double)sfs.f_bfree); | 124 { |
125 size = (long double)((double)sfs.f_bsize * (double)sfs.f_bfree); | |
126 } | |
125 } | 127 } |
126 fclose(fp); | 128 fclose(fp); |
127 return size; | 129 return size; |
128 } | 130 } |
129 index++; | 131 index++; |
131 fclose(fp); | 133 fclose(fp); |
132 } | 134 } |
133 return 0; | 135 return 0; |
134 #else | 136 #else |
135 FILE *fp = setmntent(MOUNTED, "r"); | 137 FILE *fp = setmntent(MOUNTED, "r"); |
136 struct mntent *mnt; | 138 struct mntent mnt; |
137 struct statfs sfs; | 139 struct statfs sfs; |
140 char buffer[1024]; | |
138 int index = 1; | 141 int index = 1; |
139 | 142 |
140 if(fp) | 143 if(fp) |
141 { | 144 { |
142 while((mnt = getmntent(fp))) | 145 while(getmntent_r(fp, &mnt, buffer, sizeof(buffer))) |
143 { | 146 { |
144 if(index == drive) | 147 if(index == drive) |
145 { | 148 { |
146 long double size = 0; | 149 long double size = 0; |
147 | 150 |
148 if(mnt->mnt_dir) | 151 if(mnt.mnt_dir) |
149 { | 152 { |
150 statfs(mnt->mnt_dir, &sfs); | 153 if(!statfs(mnt.mnt_dir, &sfs)) |
151 size = (long double)((double)sfs.f_bsize * (double)sfs.f_bavail); | 154 { |
155 size = (long double)((double)sfs.f_bsize * (double)sfs.f_bavail); | |
156 } | |
152 } | 157 } |
153 endmntent(fp); | 158 endmntent(fp); |
154 return size; | 159 return size; |
155 } | 160 } |
156 index++; | 161 index++; |
215 { | 220 { |
216 long double size = 0; | 221 long double size = 0; |
217 | 222 |
218 if(mnt.mnt_mountp) | 223 if(mnt.mnt_mountp) |
219 { | 224 { |
220 statfs(mnt.mnt_mountp, &sfs, sizeof(struct statfs), 0); | 225 if(!statfs(mnt.mnt_mountp, &sfs, sizeof(struct statfs), 0)) |
221 size = (long double)((double)sfs.f_bsize * (double)sfs.f_blocks); | 226 { |
227 size = (long double)((double)sfs.f_bsize * (double)sfs.f_blocks); | |
228 } | |
222 } | 229 } |
223 fclose(fp); | 230 fclose(fp); |
224 return size; | 231 return size; |
225 } | 232 } |
226 index++; | 233 index++; |
228 fclose(fp); | 235 fclose(fp); |
229 } | 236 } |
230 return 0; | 237 return 0; |
231 #else | 238 #else |
232 FILE *fp = setmntent(MOUNTED, "r"); | 239 FILE *fp = setmntent(MOUNTED, "r"); |
233 struct mntent *mnt; | 240 struct mntent mnt; |
241 char buffer[1024]; | |
234 struct statfs sfs; | 242 struct statfs sfs; |
235 int index = 1; | 243 int index = 1; |
236 | 244 |
237 if(fp) | 245 if(fp) |
238 { | 246 { |
239 while((mnt = getmntent(fp))) | 247 while(getmntent_r(fp, &mnt, buffer, sizeof(buffer))) |
240 { | 248 { |
241 if(index == drive) | 249 if(index == drive) |
242 { | 250 { |
243 long double size = 0; | 251 long double size = 0; |
244 | 252 |
245 if(mnt->mnt_dir) | 253 if(mnt.mnt_dir) |
246 { | 254 { |
247 statfs(mnt->mnt_dir, &sfs); | 255 if(!statfs(mnt.mnt_dir, &sfs)) |
248 size = (long double)((double)sfs.f_bsize * (double)sfs.f_blocks); | 256 { |
257 size = (long double)((double)sfs.f_bsize * (double)sfs.f_blocks); | |
258 } | |
249 } | 259 } |
250 endmntent(fp); | 260 endmntent(fp); |
251 return size; | 261 return size; |
252 } | 262 } |
253 index++; | 263 index++; |
308 if(index == drive) | 318 if(index == drive) |
309 { | 319 { |
310 fclose(fp); | 320 fclose(fp); |
311 if(mnt.mnt_mountp) | 321 if(mnt.mnt_mountp) |
312 { | 322 { |
313 statfs(mnt.mnt_mountp, &sfs, sizeof(struct statfs), 0); | 323 if(!statfs(mnt.mnt_mountp, &sfs, sizeof(struct statfs), 0) && sfs.f_blocks) |
314 if(sfs.f_blocks) | |
315 return 1; | 324 return 1; |
316 } | 325 } |
317 return 0; | 326 return 0; |
318 } | 327 } |
319 index++; | 328 index++; |
320 } | 329 } |
321 fclose(fp); | 330 fclose(fp); |
322 } | 331 } |
323 #else | 332 #else |
324 FILE *fp = setmntent(MOUNTED, "r"); | 333 FILE *fp = setmntent(MOUNTED, "r"); |
325 struct mntent *mnt; | 334 struct mntent mnt; |
335 char buffer[1024]; | |
326 struct statfs sfs; | 336 struct statfs sfs; |
327 int index = 1; | 337 int index = 1; |
328 | 338 |
329 if(fp) | 339 if(fp) |
330 { | 340 { |
331 while((mnt = getmntent(fp))) | 341 while(getmntent_r(fp, &mnt, buffer, sizeof(buffer))) |
332 { | 342 { |
333 if(index == drive) | 343 if(index == drive) |
334 { | 344 { |
335 endmntent(fp); | 345 endmntent(fp); |
336 if(mnt->mnt_dir) | 346 if(mnt.mnt_dir) |
337 { | 347 { |
338 statfs(mnt->mnt_dir, &sfs); | 348 if(!statfs(mnt.mnt_dir, &sfs) && sfs.f_blocks) |
339 if(sfs.f_blocks) | 349 { |
340 return 1; | 350 return 1; |
351 } | |
341 } | 352 } |
342 return 0; | 353 return 0; |
343 } | 354 } |
344 index++; | 355 index++; |
345 } | 356 } |
383 } | 394 } |
384 fclose(fp); | 395 fclose(fp); |
385 } | 396 } |
386 #else | 397 #else |
387 FILE *fp = setmntent(MOUNTED, "r"); | 398 FILE *fp = setmntent(MOUNTED, "r"); |
388 struct mntent *mnt; | 399 struct mntent mnt; |
400 char buffer[1024]; | |
389 int index = 1; | 401 int index = 1; |
390 | 402 |
391 strncpy(buf, "Unknown", len); | 403 strncpy(buf, "Unknown", len); |
392 | 404 |
393 if(fp) | 405 if(fp) |
394 { | 406 { |
395 while((mnt = getmntent(fp))) | 407 while(getmntent_r(fp, &mnt, buffer, sizeof(buffer))) |
396 { | 408 { |
397 if(index == drive && mnt->mnt_dir) | 409 if(index == drive && mnt.mnt_dir) |
398 strncpy(buf, mnt->mnt_dir, len); | 410 strncpy(buf, mnt.mnt_dir, len); |
399 index++; | 411 index++; |
400 } | 412 } |
401 endmntent(fp); | 413 endmntent(fp); |
402 } | 414 } |
403 #endif | 415 #endif |