![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs3|
Return to misc.c CVS log | Up to [Synchronet] / sbbs / sbbs3 |
1.1 root 1: /* misc.cpp */
2:
3: /* Synchronet miscellaneous utility-type routines (exported) */
4:
5: /* $Id: misc.c,v 1.9 2000/11/14 01:58:37 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 2000 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This program is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU 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 General Public License for more details: gpl.txt or *
18: * http://www.fsf.org/copyleft/gpl.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 "sbbs.h"
39: #include "crc32.h"
40:
41: /****************************************************************************/
42: /* Network open function. Opens all files DENYALL and retries LOOP_NOPEN */
43: /* number of times if the attempted file is already open or denying access */
44: /* for some other reason. All files are opened in BINARY mode. */
45: /****************************************************************************/
46: int nopen(char *str, int access)
47: {
48: int file,share,count=0;
49:
50: if(access&O_DENYNONE) {
51: share=SH_DENYNO;
52: access&=~O_DENYNONE; }
53: else if(access==O_RDONLY) share=SH_DENYWR;
54: else share=SH_DENYRW;
55: while(((file=sopen(str,O_BINARY|access,share))==-1)
56: && errno==EACCES && count++<LOOP_NOPEN)
57: if(count>10)
58: mswait(55);
59: return(file);
60: }
61: /****************************************************************************/
62: /* This function performs an nopen, but returns a file stream with a buffer */
63: /* allocated. */
64: /****************************************************************************/
65: FILE * fnopen(int *fd, char *str, int access)
66: {
67: char mode[128];
68: int file;
69: FILE * stream;
70:
71: if((file=nopen(str,access))==-1)
72: return(NULL);
73:
74: if(fd!=NULL)
75: *fd=file;
76:
77: if(access&O_APPEND) {
78: if(access&O_RDONLY)
79: strcpy(mode,"a+");
80: else
81: strcpy(mode,"a");
82: } else if(access&O_CREAT) {
83: if(access&O_TRUNC)
84: strcpy(mode,"w");
85: else
86: strcpy(mode,"w+");
87: } else {
88: if(access&O_WRONLY || (access&O_RDWR)==O_RDWR)
89: strcpy(mode,"r+");
90: else
91: strcpy(mode,"r");
92: }
93: stream=fdopen(file,mode);
94: if(stream==NULL) {
95: close(file);
96: return(NULL);
97: }
98: setvbuf(stream,NULL,_IOFBF,FNOPEN_BUF_SIZE);
99: return(stream);
100: }
101:
102: /****************************************************************************/
103: /* Returns the number of characters in 'str' not counting ctrl-ax codes */
104: /* or the null terminator */
105: /****************************************************************************/
106: int bstrlen(char *str)
107: {
108: int i=0;
109:
110: while(*str) {
111: if(*str==1) /* ctrl-a */
112: str++;
113: else
114: i++;
115: if(!(*str)) break;
116: str++; }
117: return(i);
118: }
119:
120: void strip_ctrl(char *str)
121: {
122: char tmp[1024];
123: int i,j,k;
124:
125: k=strlen(str);
126: for(i=j=0;i<k;i++)
127: if(str[i]==1) /* Ctrl-a */
128: i++;
129: else if(j && str[i]<=SP && tmp[j-1]==SP)
130: continue;
131: else if(i && !isalnum(str[i]) && str[i]==str[i-1])
132: continue;
133: else if((uchar)str[i]>=SP)
134: tmp[j++]=str[i];
135: else if(str[i]==TAB || (str[i]==CR && str[i+1]==LF))
136: tmp[j++]=SP;
137: tmp[j]=0;
138: strcpy(str,tmp);
139: }
140:
141: void strip_exascii(char *str)
142: {
143: char tmp[1024];
144: int i,j,k;
145:
146: k=strlen(str);
147: for(i=j=0;i<k;i++)
148: if(!(str[i]&0x80))
149: tmp[j++]=str[i];
150: tmp[j]=0;
151: strcpy(str,tmp);
152: }
153:
154: /****************************************************************************/
155: /* Returns in 'string' a character representation of the number in l with */
156: /* commas. */
157: /****************************************************************************/
158: char *ultoac(ulong l, char *string)
159: {
160: char str[256];
161: char i,j,k;
162:
163: ultoa(l,str,10);
164: i=strlen(str)-1;
165: j=i/3+1+i;
166: string[j--]=0;
167: for(k=1;i>-1;k++) {
168: string[j--]=str[i--];
169: if(j>0 && !(k%3))
170: string[j--]=','; }
171: return(string);
172: }
173:
174: /****************************************************************************/
175: /* Truncates white-space chars off end of 'str' */
176: /****************************************************************************/
177: void truncsp(char *str)
178: {
179: uint c;
180:
181: #if 0 /* no longer terminates at first tab OCT-09-2000 rswindell */
182: str[strcspn(str,"\t")]=0;
183: #endif
184: c=strlen(str);
185: while(c && (uchar)str[c-1]<=SP) c--;
186: str[c]=0;
187: }
188:
189: /****************************************************************************/
190: /* Puts a backslash on path strings */
191: /****************************************************************************/
192: void backslash(char *str)
193: {
194: int i;
195:
196: i=strlen(str);
197: if(i && str[i-1]!='\\' && str[i-1]!='/') {
198: str[i]=BACKSLASH;
199: str[i+1]=0;
200: }
201: }
202:
203: /****************************************************************************/
204: /* Puts a backslash on path strings if not just a drive letter and colon */
205: /****************************************************************************/
206: void backslashcolon(char *str)
207: {
208: int i;
209:
210: i=strlen(str);
211: if(i && str[i-1]!='\\' && str[i-1]!='/' && str[i-1]!=':') {
212: str[i]=BACKSLASH;
213: str[i+1]=0;
214: }
215: }
216:
217: /****************************************************************************/
218: /* Updates 16-bit "rcrc" with character 'ch' */
219: /****************************************************************************/
220: void ucrc16(uchar ch, ushort *rcrc)
221: {
222: ushort i, cy;
223: uchar nch=ch;
224:
225: for (i=0; i<8; i++) {
226: cy=*rcrc & 0x8000;
227: *rcrc<<=1;
228: if (nch & 0x80) *rcrc |= 1;
229: nch<<=1;
230: if (cy) *rcrc ^= 0x1021; }
231: }
232:
233: /****************************************************************************/
234: /* Returns CRC-16 of string (not including terminating NULL) */
235: /****************************************************************************/
236: ushort DLLCALL crc16(char *str)
237: {
238: int i=0;
239: ushort crc=0;
240:
241: ucrc16(0,&crc);
242: while(str[i])
243: ucrc16(str[i++],&crc);
244: ucrc16(0,&crc);
245: ucrc16(0,&crc);
246: return(crc);
247: }
248:
249: /****************************************************************************/
250: /* Returns CRC-32 of string (not including terminating NULL) */
251: /****************************************************************************/
252: ulong crc32(char *buf, ulong len)
253: {
254: ulong l,crc=0xffffffff;
255:
256: for(l=0;l<len;l++)
257: crc=ucrc32(buf[l],crc);
258: return(~crc);
259: }
260:
261: /****************************************************************************/
262: /* Compares pointers to pointers to char. Used in conjuction with qsort() */
263: /****************************************************************************/
264: int pstrcmp(char **str1, char **str2)
265: {
266: return(strcmp(*str1,*str2));
267: }
268:
269: /****************************************************************************/
270: /* Returns the number of characters that are the same between str1 and str2 */
271: /****************************************************************************/
272: int strsame(char *str1, char *str2)
273: {
274: int i,j=0;
275:
276: for(i=0;str1[i];i++)
277: if(str1[i]==str2[i]) j++;
278: return(j);
279: }
280:
281: #define MV_BUFLEN 4096
282:
283: /****************************************************************************/
284: /* Converts when_t.zone into ASCII format */
285: /****************************************************************************/
286: char* DLLCALL zonestr(short zone)
287: {
288: static char str[32];
289:
290: switch((ushort)zone) {
291: case 0: return("UT");
292: case AST: return("AST");
293: case EST: return("EST");
294: case CST: return("CST");
295: case MST: return("MST");
296: case PST: return("PST");
297: case YST: return("YST");
298: case HST: return("HST");
299: case BST: return("BST");
300: case ADT: return("ADT");
301: case EDT: return("EDT");
302: case CDT: return("CDT");
303: case MDT: return("MDT");
304: case PDT: return("PDT");
305: case YDT: return("YDT");
306: case HDT: return("HDT");
307: case BDT: return("BDT");
308: case MID: return("MID");
309: case VAN: return("VAN");
310: case EDM: return("EDM");
311: case WIN: return("WIN");
312: case BOG: return("BOG");
313: case CAR: return("CAR");
314: case RIO: return("RIO");
315: case FER: return("FER");
316: case AZO: return("AZO");
317: case LON: return("LON");
318: case BER: return("BER");
319: case ATH: return("ATH");
320: case MOS: return("MOS");
321: case DUB: return("DUB");
322: case KAB: return("KAB");
323: case KAR: return("KAR");
324: case BOM: return("BOM");
325: case KAT: return("KAT");
326: case DHA: return("DHA");
327: case BAN: return("BAN");
328: case HON: return("HON");
329: case TOK: return("TOK");
330: case SYD: return("SYD");
331: case NOU: return("NOU");
332: case WEL: return("WEL");
333: }
334:
335: sprintf(str,"%02d:%02u",zone/60,zone<0 ? (-zone)%60 : zone%60);
336: return(str);
337: }
338:
339:
340: /****************************************************************************/
341: /* Returns an ASCII string for FidoNet address 'addr' */
342: /****************************************************************************/
343: char *faddrtoa(faddr_t addr)
344: {
345: static char str[25];
346: char point[25];
347:
348: sprintf(str,"%u:%u/%u",addr.zone,addr.net,addr.node);
349: if(addr.point) {
350: sprintf(point,".%u",addr.point);
351: strcat(str,point); }
352: return(str);
353: }
354:
355: /****************************************************************************/
356: /* Returns string for 2 digit hex+ numbers up to 575 */
357: /****************************************************************************/
358: char *hexplus(uint num, char *str)
359: {
360: sprintf(str,"%03x",num);
361: str[0]=num/0x100 ? 'f'+(num/0x10)-0xf : str[1];
362: str[1]=str[2];
363: str[2]=0;
364: return(str);
365: }
366:
367: uint hptoi(char *str)
368: {
369: char tmp[128];
370: uint i;
371:
372: if(!str[1] || toupper(str[0])<='F')
373: return(ahtoul(str));
374: strcpy(tmp,str);
375: tmp[0]='F';
376: i=ahtoul(tmp)+((toupper(str[0])-'F')*0x10);
377: return(i);
378: }
379:
380: /****************************************************************************/
381: /* Converts an ASCII Hex string into an ulong */
382: /****************************************************************************/
383: ulong ahtoul(char *str)
384: {
385: ulong l,val=0;
386:
387: while((l=(*str++)|0x20)!=0x20)
388: val=(l&0xf)+(l>>6&1)*9+val*16;
389: return(val);
390: }
391:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.