![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genwrap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / xpdev|
Return to genwrap.c CVS log | Up to [Synchronet] / sbbs / src / xpdev |
1.1 root 1: /* genwrap.c */
2:
3: /* General cross-platform development wrappers */
4:
5: /* $Id: genwrap.c,v 1.72 2006/08/26 18:45:48 rswindell Exp $ */
6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
11: * Copyright 2006 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This library is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU Lesser General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU Lesser General Public License for more details: lgpl.txt or *
18: * http://www.fsf.org/copyleft/lesser.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: #include <string.h> /* strlen() */
39: #include <stdarg.h> /* vsnprintf() */
40: #include <stdlib.h> /* RAND_MAX */
41: #include <fcntl.h> /* O_NOCTTY */
42: #include <time.h> /* clock() */
43: #include <errno.h> /* errno */
44: #include <ctype.h> /* toupper/tolower */
45:
46: #if defined(__unix__)
47: #include <sys/ioctl.h> /* ioctl() */
48: #include <sys/utsname.h> /* uname() */
49: #endif /* __unix__ */
50:
51: #include "genwrap.h" /* Verify prototypes */
52: #include "xpendian.h" /* BYTE_SWAP */
53:
54: /****************************************************************************/
55: /* Used to replace snprintf() guarantees to terminate. */
56: /****************************************************************************/
57: int DLLCALL safe_snprintf(char *dst, size_t size, const char *fmt, ...)
58: {
59: va_list argptr;
60: int numchars;
61:
62: va_start(argptr,fmt);
63: numchars= vsnprintf(dst,size,fmt,argptr);
64: va_end(argptr);
65: dst[size-1]=0;
66: #ifdef _MSC_VER
67: if(numchars==-1)
68: numchars=strlen(dst);
69: #endif
70: if(numchars>=(int)size && numchars>0)
71: numchars=size-1;
72: return(numchars);
73: }
74:
75: /****************************************************************************/
76: /* Return last character of string */
77: /****************************************************************************/
78: char* DLLCALL lastchar(const char* str)
79: {
80: size_t len;
81:
82: len = strlen(str);
83:
84: if(len)
85: return((char*)&str[len-1]);
86:
87: return((char*)str);
88: }
89:
90: /****************************************************************************/
91: /* Return character value of C-escaped (\) character */
92: /****************************************************************************/
93: char DLLCALL c_unescape_char(char ch)
94: {
95: switch(ch) {
96: case 'e': return(ESC); /* non-standard */
97: case 'a': return('\a');
98: case 'b': return('\b');
99: case 'f': return('\f');
100: case 'n': return('\n');
101: case 'r': return('\r');
102: case 't': return('\t');
103: case 'v': return('\v');
104: }
105: return(ch);
106: }
107:
108: /****************************************************************************/
109: /* Return character value of C-escaped (\) character sequence */
110: /* (supports \Xhh and \0ooo escape sequences) */
111: /* This code currently has problems with sequences like: "\x01blue" */
112: /****************************************************************************/
113: char DLLCALL c_unescape_char_ptr(const char* str, char** endptr)
114: {
115: char ch;
116:
117: if(toupper(*str)=='X')
118: ch=(char)strtol(++str,endptr,16);
119: else if(isdigit(*str))
120: ch=(char)strtol(++str,endptr,8);
121: else {
122: ch=c_unescape_char(*(str++));
123: if(endptr!=NULL)
124: *endptr=(char*)str;
125: }
126:
127: return(ch);
128: }
129:
130: /****************************************************************************/
131: /* Unescape a C string, in place */
132: /****************************************************************************/
133: char* DLLCALL c_unescape_str(char* str)
134: {
135: char ch;
136: char* buf;
137: char* src;
138: char* dst;
139:
140: if(str==NULL || (buf=strdup(str))==NULL)
141: return(NULL);
142:
143: src=buf;
144: dst=str;
145: while((ch=*(src++))!=0) {
146: if(ch=='\\') /* escape */
147: ch=c_unescape_char_ptr(src,&src);
148: *(dst++)=ch;
149: }
150: *dst=0;
151: free(buf);
152: return(str);
153: }
154:
155: char* DLLCALL c_escape_char(char ch)
156: {
157: switch(ch) {
158: case 0: return("\\x00");
159: case 1: return("\\x01");
160: case ESC: return("\\e"); /* non-standard */
161: case '\a': return("\\a");
162: case '\b': return("\\b");
163: case '\f': return("\\f");
164: case '\n': return("\\n");
165: case '\r': return("\\r");
166: case '\t': return("\\t");
167: case '\v': return("\\v");
168: case '\\': return("\\\\");
169: case '\"': return("\\\"");
170: case '\'': return("\\'");
171: }
172: return(NULL);
173: }
174:
175: char* DLLCALL c_escape_str(const char* src, char* dst, size_t maxlen, BOOL ctrl_only)
176: {
177: const char* s;
178: char* d;
179: char* e;
180:
181: for(s=src,d=dst;*s && (size_t)(d-dst)<maxlen;s++,d++) {
182: if((!ctrl_only || (uchar)*s < ' ') && (e=c_escape_char(*s))!=NULL) {
183: *d=0;
184: strncat(dst,e,maxlen-(d-dst));
185: d++;
186: } else *d=*s;
187: }
188: *d=0;
189:
190: return(dst);
191: }
192:
193: /****************************************************************************/
194: /* Convert ASCIIZ string to upper case */
195: /****************************************************************************/
196: #if defined(__unix__)
197: char* DLLCALL strupr(char* str)
198: {
199: char* p=str;
200:
201: while(*p) {
202: *p=toupper(*p);
203: p++;
204: }
205: return(str);
206: }
207: /****************************************************************************/
208: /* Convert ASCIIZ string to lower case */
209: /****************************************************************************/
210: char* DLLCALL strlwr(char* str)
211: {
212: char* p=str;
213:
214: while(*p) {
215: *p=tolower(*p);
216: p++;
217: }
218: return(str);
219: }
220: /****************************************************************************/
221: /* Reverse characters of a string (provided by amcleod) */
222: /****************************************************************************/
223: char* strrev(char* str)
224: {
225: char t, *i=str, *j=str+strlen(str);
226:
227: while (i<j) {
228: t=*i; *(i++)=*(--j); *j=t;
229: }
230: return str;
231: }
232: #endif
233:
234: #if !defined(__unix__)
235:
236: /****************************************************************************/
237: /* Implementations of the recursive (thread-safe) version of strtok */
238: /* Thanks to Apache Portable Runtime (APR) */
239: /****************************************************************************/
240: char* DLLCALL strtok_r(char *str, const char *delim, char **last)
241: {
242: char* token;
243:
244: if (str==NULL) /* subsequent call */
245: str = *last; /* start where we left off */
246:
247: /* skip characters in delimiter (will terminate at '\0') */
248: while(*str && strchr(delim, *str))
249: ++str;
250:
251: if(!*str) { /* no more tokens */
252: *last = str;
253: return NULL;
254: }
255:
256: token = str;
257:
258: /* skip valid token characters to terminate token and
259: * prepare for the next call (will terminate at '\0)
260: */
261: *last = token + 1;
262: while(**last && !strchr(delim, **last))
263: ++*last;
264:
265: if (**last) {
266: **last = '\0';
267: ++*last;
268: }
269:
270: return token;
271: }
272:
273: #endif
274:
275: /****************************************************************************/
276: /* Initialize (seed) the random number generator */
277: /****************************************************************************/
278: unsigned DLLCALL xp_randomize(void)
279: {
280: unsigned seed=~0;
281:
282: #if defined(HAS_DEV_URANDOM) && defined(URANDOM_DEV)
283: int rf;
284:
285: if((rf=open(URANDOM_DEV, O_RDONLY))!=-1) {
286: read(rf, &seed, sizeof(seed));
287: close(rf);
288: }
289: else {
290: #endif
291: unsigned curtime = (unsigned)time(NULL);
292: unsigned process_id = (unsigned)GetCurrentProcessId();
293:
294: seed = curtime ^ BYTE_SWAP_INT(process_id);
295:
296: #if defined(_WIN32) || defined(GetCurrentThreadId)
297: seed ^= (unsigned)GetCurrentThreadId();
298: #endif
299:
300: #if defined(HAS_DEV_URANDOM) && defined(URANDOM_DEV)
301: }
302: #endif
303:
304: #ifdef HAS_RANDOM_FUNC
305: srandom(seed);
306: return(seed);
307: #else
308: srand(seed);
309: return(seed);
310: #endif
311: }
312:
313: /****************************************************************************/
314: /* Return random number between 0 and n-1 */
315: /****************************************************************************/
316: int DLLCALL xp_random(int n)
317: {
318: #ifdef HAS_RANDOM_FUNC
319: if(n<2)
320: return(0);
321: return(random()%n);
322: #else
323: float f=0;
324:
325: if(n<2)
326: return(0);
327: f=(float)rand()/(float)RAND_MAX;
328:
329: return((int)(n*f));
330: #endif
331: }
332:
333: /****************************************************************************/
334: /* Return ASCII string representation of ulong */
335: /* There may be a native GNU C Library function to this... */
336: /****************************************************************************/
337: #if !defined(_MSC_VER) && !defined(__BORLANDC__) && !defined(__WATCOMC__)
338: char* DLLCALL ultoa(ulong val, char* str, int radix)
339: {
340: switch(radix) {
341: case 8:
342: sprintf(str,"%lo",val);
343: break;
344: case 10:
345: sprintf(str,"%lu",val);
346: break;
347: case 16:
348: sprintf(str,"%lx",val);
349: break;
350: default:
351: sprintf(str,"bad radix: %d",radix);
352: break;
353: }
354: return(str);
355: }
356: #endif
357:
358: /****************************************************************************/
359: /* Write the version details of the current operating system into str */
360: /****************************************************************************/
361: char* DLLCALL os_version(char *str)
362: {
363: #if defined(__OS2__) && defined(__BORLANDC__)
364:
365: sprintf(str,"OS/2 %u.%u (%u.%u)",_osmajor/10,_osminor/10,_osmajor,_osminor);
366:
367: #elif defined(_WIN32)
368:
369: /* Windows Version */
370: char* winflavor="";
371: OSVERSIONINFO winver;
372:
373: winver.dwOSVersionInfoSize=sizeof(winver);
374: GetVersionEx(&winver);
375:
376: switch(winver.dwPlatformId) {
377: case VER_PLATFORM_WIN32_NT:
378: winflavor="NT ";
379: break;
380: case VER_PLATFORM_WIN32s:
381: winflavor="Win32s ";
382: break;
383: case VER_PLATFORM_WIN32_WINDOWS:
384: winver.dwBuildNumber&=0xffff;
385: break;
386: }
387:
388: sprintf(str,"Windows %sVersion %u.%u (Build %u) %s"
389: ,winflavor
390: ,winver.dwMajorVersion, winver.dwMinorVersion
391: ,winver.dwBuildNumber,winver.szCSDVersion);
392:
393: #elif defined(__unix__)
394:
395: struct utsname unixver;
396:
397: if(uname(&unixver)<0)
398: sprintf(str,"Unix (uname errno: %d)",errno);
399: else
400: sprintf(str,"%s %s %s"
401: ,unixver.sysname /* e.g. "Linux" */
402: ,unixver.release /* e.g. "2.2.14-5.0" */
403: ,unixver.machine /* e.g. "i586" */
404: );
405:
406: #else /* DOS */
407:
408: sprintf(str,"DOS %u.%02u",_osmajor,_osminor);
409:
410: #endif
411:
412: return(str);
413: }
414:
415: char* DLLCALL os_cmdshell(void)
416: {
417: char* shell=getenv(OS_CMD_SHELL_ENV_VAR);
418:
419: #if !defined(__unix__)
420: if(shell==NULL)
421: #ifdef _PATH_BSHELL
422: shell=_PATH_BSHELL;
423: #else
424: shell="/bin/sh";
425: #endif
426: #endif
427:
428: return(shell);
429: }
430:
431: #if !defined(__unix__)
432:
433: /****************************************************************************/
434: /* Win32 implementations of the recursive (thread-safe) versions of std C */
435: /* time functions (gmtime, localtime, ctime, and asctime) used in Unix. */
436: /* The native Win32 versions of these functions are already thread-safe. */
437: /****************************************************************************/
438:
439: struct tm* DLLCALL gmtime_r(const time_t* t, struct tm* tm)
440: {
441: struct tm* tmp = gmtime(t);
442:
443: if(tmp==NULL)
444: return(NULL);
445:
446: *tm = *tmp;
447: return(tm);
448: }
449:
450: struct tm* DLLCALL localtime_r(const time_t* t, struct tm* tm)
451: {
452: struct tm* tmp = localtime(t);
453:
454: if(tmp==NULL)
455: return(NULL);
456:
457: *tm = *tmp;
458: return(tm);
459: }
460:
461: char* DLLCALL ctime_r(const time_t *t, char *buf)
462: {
463: char* p = ctime(t);
464:
465: if(p==NULL)
466: return(NULL);
467:
468: strcpy(buf,p);
469: return(buf);
470: }
471:
472: char* DLLCALL asctime_r(const struct tm *tm, char *buf)
473: {
474: char* p = asctime(tm);
475:
476: if(p==NULL)
477: return(NULL);
478:
479: strcpy(buf,p);
480: return(buf);
481: }
482:
483: #endif /* !defined(__unix__) */
484:
485: /****************************************************************/
486: /* Microsoft (DOS/Win32) real-time system clock implementation. */
487: /****************************************************************/
488: #ifdef __unix__
489: clock_t DLLCALL msclock(void)
490: {
491: long long int usecs;
492: struct timeval tv;
493: if(gettimeofday(&tv,NULL)==1)
494: return(-1);
495: usecs=tv.tv_sec*1000000+tv.tv_usec;
496: return((clock_t)(usecs/(1000000/MSCLOCKS_PER_SEC)));
497: }
498: #endif
499:
500: /****************************************************************************/
501: /* Truncates all white-space chars off end of 'str' (needed by STRERRROR) */
502: /****************************************************************************/
503: char* DLLCALL truncsp(char* str)
504: {
505: size_t i,len;
506:
507: i=len=strlen(str);
508: while(i && (str[i-1]==' ' || str[i-1]=='\t' || str[i-1]=='\r' || str[i-1]=='\n'))
509: i--;
510: if(i!=len)
511: str[i]=0; /* truncate */
512:
513: return(str);
514: }
515:
516: /****************************************************************************/
517: /* Truncates all white-space chars off end of \n-terminated lines in 'str' */
518: /****************************************************************************/
519: char* DLLCALL truncsp_lines(char* dst)
520: {
521: char* sp;
522: char* dp;
523: char* src;
524:
525: if((src=strdup(dst))==NULL)
526: return(dst);
527:
528: for(sp=src, dp=dst; *sp!=0; sp++) {
529: if(*sp=='\n')
530: while(dp!=dst
531: && (*(dp-1)==' ' || *(dp-1)=='\t' || *(dp-1)=='\r') && *(dp-1)!='\n')
532: dp--;
533: *(dp++)=*sp;
534: }
535: *dp=0;
536:
537: free(src);
538: return(dst);
539: }
540:
541: /****************************************************************************/
542: /* Truncates carriage-return and line-feed chars off end of 'str' */
543: /****************************************************************************/
544: char* DLLCALL truncnl(char* str)
545: {
546: size_t i,len;
547:
548: i=len=strlen(str);
549: while(i && (str[i-1]=='\r' || str[i-1]=='\n'))
550: i--;
551: if(i!=len)
552: str[i]=0; /* truncate */
553:
554: return(str);
555: }
556:
557: /****************************************************************************/
558: /* Return errno from the proper C Library implementation */
559: /* (single/multi-threaded) */
560: /****************************************************************************/
561: int DLLCALL get_errno(void)
562: {
563: return(errno);
564: }
565:
566: /****************************************************************************/
567: /* Returns the current value of the systems best timer (in SECONDS) */
568: /* Any value < 0 indicates an error */
569: /****************************************************************************/
570: long double DLLCALL xp_timer(void)
571: {
572: long double ret;
573: #if defined(__unix__)
574: struct timeval tv;
575: if(gettimeofday(&tv,NULL)==1)
576: return(-1);
577: ret=tv.tv_usec;
578: ret /= 1000000;
579: ret += tv.tv_sec;
580: #elif defined(_WIN32)
581: LARGE_INTEGER freq;
582: LARGE_INTEGER tick;
583: if(QueryPerformanceFrequency(&freq) && QueryPerformanceCounter(&tick)) {
584: #if 0
585: ret=((long double)tick.HighPart*4294967296)+((long double)tick.LowPart);
586: ret /= ((long double)freq.HighPart*4294967296)+((long double)freq.LowPart);
587: #else
588: /* In MSVC, a long double does NOT have 19 decimals of precision */
589: ret=(((long double)(tick.QuadPart%freq.QuadPart))/freq.QuadPart);
590: ret+=tick.QuadPart/freq.QuadPart;
591: #endif
592: }
593: else {
594: ret=GetTickCount();
595: ret /= 1000;
596: }
597: #else
598: ret=time(NULL); /* Weak implementation */
599: #endif
600: return(ret);
601: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.