Mercurial > dwindows

comparison compat.c @ 649:3e2ada9ee0ac

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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