![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to smbstr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / smblib|
Return to smbstr.c CVS log | Up to [Synchronet] / sbbs / src / smblib |
1.1 root 1: /* smbstr.c */
2:
3: /* Synchronet message base (SMB) library routines returning strings */
4:
1.1.1.2 ! root 5: /* $Id: smbstr.c,v 1.22 2011/08/31 04:12:34 rswindell Exp $ */
1.1 root 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: * *
1.1.1.2 ! root 11: * Copyright 2011 Rob Swindell - http://www.synchro.net/copyright.html *
1.1 root 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 <ctype.h> /* is*() */
39: #include <string.h> /* strcpy, strcat, memset, strchr */
40: #include <genwrap.h> /* stricmp */
41: #include "smblib.h"
42:
43: char* SMBCALL smb_hfieldtype(ushort type)
44: {
45: static char str[8];
46:
47: switch(type) {
1.1.1.2 ! root 48: case SENDER: return("Sender"); /* RFC-compliant */
1.1 root 49: case SENDERAGENT: return("SenderAgent");
50: case SENDERNETTYPE: return("SenderNetType");
51: case SENDERNETADDR: return("SenderNetAddr");
52: case SENDEREXT: return("SenderExt");
1.1.1.2 ! root 53: case SENDERORG: return("Organization"); /* RFC-compliant */
1.1 root 54: case SENDERIPADDR: return("SenderIpAddr");
55: case SENDERHOSTNAME: return("SenderHostName");
56: case SENDERPROTOCOL: return("SenderProtocol");
1.1.1.2 ! root 57: case SENDERPORT_BIN: return("SenderPortBin");
1.1 root 58: case SENDERPORT: return("SenderPort");
1.1.1.2 ! root 59: case SENDERUSERID: return("SenderUserID");
! 60: case SENDERTIME: return("SenderTime");
! 61: case SENDERSERVER: return("SenderServer");
! 62:
! 63: case REPLYTO: return("Reply-To"); /* RFC-compliant */
! 64: case REPLYTOAGENT: return("Reply-ToAgent");
! 65: case REPLYTONETTYPE: return("Reply-ToNetType");
! 66: case REPLYTONETADDR: return("Reply-ToNetAddr");
! 67: case REPLYTOEXT: return("Reply-ToExt");
1.1 root 68:
1.1.1.2 ! root 69: case RECIPIENT: return("To"); /* RFC-compliant */
! 70: case RECIPIENTAGENT: return("ToAgent");
! 71: case RECIPIENTNETTYPE: return("ToNetType");
! 72: case RECIPIENTNETADDR: return("ToNetAddr");
! 73: case RECIPIENTEXT: return("ToExt");
1.1 root 74:
1.1.1.2 ! root 75: case SUBJECT: return("Subject"); /* RFC-compliant */
1.1 root 76: case SMB_SUMMARY: return("Summary");
1.1.1.2 ! root 77: case SMB_COMMENT: return("Comment"); /* RFC-compliant */
! 78: case SMB_CARBONCOPY: return("CC"); /* RFC-compliant */
1.1 root 79: case SMB_GROUP: return("Group");
80: case SMB_EXPIRATION: return("Expiration");
81: case SMB_PRIORITY: return("Priority");
82: case SMB_COST: return("Cost");
1.1.1.2 ! root 83: case SMB_EDITOR: return("Editor");
! 84: case FORWARDED: return("Forwarded");
1.1 root 85:
1.1.1.2 ! root 86: /* All X-FTN-* are RFC-compliant */
! 87: case FIDOCTRL: return("X-FTN-Kludge");
! 88: case FIDOAREA: return("X-FTN-AREA");
! 89: case FIDOSEENBY: return("X-FTN-SEEN-BY");
! 90: case FIDOPATH: return("X-FTN-PATH");
! 91: case FIDOMSGID: return("X-FTN-MSGID");
! 92: case FIDOREPLYID: return("X-FTN-REPLY");
! 93: case FIDOPID: return("X-FTN-PID");
! 94: case FIDOFLAGS: return("X-FTN-Flags");
! 95: case FIDOTID: return("X-FTN-TID");
! 96:
! 97: case RFC822HEADER: return("OtherHeader");
! 98: case RFC822MSGID: return("Message-ID"); /* RFC-compliant */
! 99: case RFC822REPLYID: return("In-Reply-To"); /* RFC-compliant */
1.1 root 100: case RFC822TO: return("RFC822To");
101: case RFC822FROM: return("RFC822From");
102: case RFC822REPLYTO: return("RFC822ReplyTo");
103:
1.1.1.2 ! root 104: case USENETPATH: return("Path"); /* RFC-compliant */
! 105: case USENETNEWSGROUPS: return("Newsgroups"); /* RFC-compliant */
1.1 root 106:
107: case SMTPCOMMAND: return("SMTPCommand");
1.1.1.2 ! root 108: case SMTPREVERSEPATH: return("Return-Path"); /* RFC-compliant */
1.1 root 109: case SMTPFORWARDPATH: return("SMTPForwardPath");
1.1.1.2 ! root 110: case SMTPRECEIVED: return("Received"); /* RFC-compliant */
1.1 root 111:
112: case SMTPSYSMSG: return("SMTPSysMsg");
113:
114: case UNKNOWN: return("UNKNOWN");
115: case UNKNOWNASCII: return("UNKNOWNASCII");
116: case UNUSED: return("UNUSED");
117: }
118: sprintf(str,"%02Xh",type);
119: return(str);
120: }
121:
122: ushort SMBCALL smb_hfieldtypelookup(const char* str)
123: {
124: ushort type;
125:
126: if(isdigit(*str))
127: return((ushort)strtol(str,NULL,0));
128:
129: for(type=0;type<=UNUSED;type++)
130: if(stricmp(str,smb_hfieldtype(type))==0)
131: return(type);
132:
133: return(UNKNOWN);
134: }
135:
136: char* SMBCALL smb_dfieldtype(ushort type)
137: {
138: static char str[8];
139:
140: switch(type) {
141: case TEXT_BODY: return("TEXT_BODY");
142: case TEXT_TAIL: return("TEXT_TAIL");
143: case UNUSED: return("UNUSED");
144: }
145: sprintf(str,"%02Xh",type);
146: return(str);
147: }
148:
149: char* SMBCALL smb_hashsourcetype(uchar type)
150: {
151: static char str[8];
152:
153: switch(type) {
154: case SMB_HASH_SOURCE_BODY: return(smb_dfieldtype(TEXT_BODY));
155: case SMB_HASH_SOURCE_MSG_ID: return(smb_hfieldtype(RFC822MSGID));
156: case SMB_HASH_SOURCE_FTN_ID: return(smb_hfieldtype(FIDOMSGID));
1.1.1.2 ! root 157: case SMB_HASH_SOURCE_SUBJECT: return(smb_hfieldtype(SUBJECT));
1.1 root 158: }
159: sprintf(str,"%02Xh",type);
160: return(str);
161: }
162:
163: char* SMBCALL smb_hashsource(smbmsg_t* msg, int source)
164: {
165: switch(source) {
166: case SMB_HASH_SOURCE_MSG_ID:
167: return(msg->id);
168: case SMB_HASH_SOURCE_FTN_ID:
169: return(msg->ftn_msgid);
1.1.1.2 ! root 170: case SMB_HASH_SOURCE_SUBJECT:
! 171: return(msg->subj);
1.1 root 172: }
173: return("hash");
174: }
175:
176: /****************************************************************************/
177: /* Converts when_t.zone into ASCII format */
178: /****************************************************************************/
1.1.1.2 ! root 179: char* SMBCALL smb_zonestr(short zone, char* str)
1.1 root 180: {
181: char* plus;
1.1.1.2 ! root 182: static char buf[32];
1.1 root 183:
1.1.1.2 ! root 184: if(str==NULL)
! 185: str=buf;
1.1 root 186: switch((ushort)zone) {
187: case 0: return("UTC");
188: case AST: return("AST");
189: case EST: return("EST");
190: case CST: return("CST");
191: case MST: return("MST");
192: case PST: return("PST");
193: case YST: return("YST");
194: case HST: return("HST");
195: case BST: return("BST");
196: case ADT: return("ADT");
197: case EDT: return("EDT");
198: case CDT: return("CDT");
199: case MDT: return("MDT");
200: case PDT: return("PDT");
201: case YDT: return("YDT");
202: case HDT: return("HDT");
203: case BDT: return("BDT");
204: case MID: return("MID");
205: case VAN: return("VAN");
206: case EDM: return("EDM");
207: case WIN: return("WIN");
208: case BOG: return("BOG");
209: case CAR: return("CAR");
210: case RIO: return("RIO");
211: case FER: return("FER");
212: case AZO: return("AZO");
213: case LON: return("LON");
214: case BER: return("BER");
215: case ATH: return("ATH");
216: case MOS: return("MOS");
217: case DUB: return("DUB");
218: case KAB: return("KAB");
219: case KAR: return("KAR");
220: case BOM: return("BOM");
221: case KAT: return("KAT");
222: case DHA: return("DHA");
223: case BAN: return("BAN");
224: case HON: return("HON");
225: case TOK: return("TOK");
226: case SYD: return("SYD");
227: case NOU: return("NOU");
228: case WEL: return("WEL");
229: }
230:
231: if(!OTHER_ZONE(zone)) {
232: if(zone&(WESTERN_ZONE|US_ZONE)) /* West of UTC? */
233: zone=-(zone&0xfff);
234: else
235: zone&=0xfff;
236: }
237:
238: if(zone>0)
239: plus="+";
240: else
241: plus="";
242: sprintf(str,"UTC%s%d:%02u", plus, zone/60, zone<0 ? (-zone)%60 : zone%60);
243:
1.1.1.2 ! root 244: return(str);
1.1 root 245: }
246:
247: /****************************************************************************/
248: /* Returns an ASCII string for FidoNet address 'addr' */
249: /****************************************************************************/
1.1.1.2 ! root 250: char* SMBCALL smb_faddrtoa(fidoaddr_t* addr, char* str)
1.1 root 251: {
1.1.1.2 ! root 252: static char buf[64];
1.1 root 253: char point[25];
254:
255: if(addr==NULL)
256: return("0:0/0");
1.1.1.2 ! root 257: if(str==NULL)
! 258: str=buf;
1.1 root 259: sprintf(str,"%hu:%hu/%hu",addr->zone,addr->net,addr->node);
260: if(addr->point) {
261: sprintf(point,".%hu",addr->point);
262: strcat(str,point);
263: }
1.1.1.2 ! root 264: return(str);
1.1 root 265: }
266:
267: /****************************************************************************/
268: /* Returns the FidoNet address parsed from str. */
269: /****************************************************************************/
270: fidoaddr_t SMBCALL smb_atofaddr(const fidoaddr_t* sys_addr, const char *str)
271: {
272: char *p;
273: fidoaddr_t addr;
274: fidoaddr_t tmp_addr={1,1,1,0}; /* Default system address: 1:1/1.0 */
275:
276: if(sys_addr==NULL)
277: sys_addr=&tmp_addr;
278:
279: ZERO_VAR(addr);
280: if((p=strchr(str,':'))!=NULL) {
281: addr.zone=atoi(str);
282: addr.net=atoi(p+1);
283: } else {
284: addr.zone=sys_addr->zone;
285: addr.net=atoi(str);
286: }
287: if(addr.zone==0) /* no such thing as zone 0 */
288: addr.zone=1;
289: if((p=strchr(str,'/'))!=NULL)
290: addr.node=atoi(p+1);
291: else {
292: if(addr.zone==sys_addr->zone)
293: addr.net=sys_addr->net;
294: addr.node=atoi(str);
295: }
296: if((p=strchr(str,'.'))!=NULL)
297: addr.point=atoi(p+1);
298: return(addr);
299: }
300:
301: /****************************************************************************/
302: /* Returns ASCIIZ representation of network address (net_t) */
1.1.1.2 ! root 303: /* NOT THREAD-SAFE! */
1.1 root 304: /****************************************************************************/
305: char* SMBCALL smb_netaddr(net_t* net)
306: {
1.1.1.2 ! root 307: return(smb_netaddrstr(net, NULL));
! 308: }
! 309:
! 310: /****************************************************************************/
! 311: /* Copies ASCIIZ representation of network address (net_t) into buf */
! 312: /****************************************************************************/
! 313: char* SMBCALL smb_netaddrstr(net_t* net, char* fidoaddr_buf)
! 314: {
1.1 root 315: if(net->type==NET_FIDO)
1.1.1.2 ! root 316: return(smb_faddrtoa((fidoaddr_t*)net->addr,fidoaddr_buf));
1.1 root 317: return(net->addr);
318: }
319:
320: /****************************************************************************/
321: /* Returns net_type for passed e-mail address (i.e. "user@addr") */
322: /****************************************************************************/
323: ushort SMBCALL smb_netaddr_type(const char* str)
324: {
325: char* p;
326: char* tp;
1.1.1.2 ! root 327: char* firstdot;
! 328: char* lastdot;
1.1 root 329:
330: if((p=strchr(str,'@'))==NULL)
331: return(NET_NONE);
332:
333: p++;
334: SKIP_WHITESPACE(p);
335: if(*p==0)
336: return(NET_UNKNOWN);
337:
1.1.1.2 ! root 338: firstdot=strchr(p,'.');
! 339: lastdot=strrchr(p,'.');
! 340:
! 341: if(isalpha(*p) && firstdot==NULL)
1.1 root 342: return(NET_QWK);
343:
344: for(tp=p;*tp;tp++) {
345: if(!isdigit(*tp) && *tp!=':' && *tp!='/' && *tp!='.')
346: break;
347: }
1.1.1.2 ! root 348: if(isdigit(*p) && *tp==0 && firstdot==lastdot)
1.1 root 349: return(NET_FIDO);
350: if(isalnum(*p))
351: return(NET_INTERNET);
352:
353: return(NET_UNKNOWN);
354: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.