Return to smbstr.c CVS log

Up to [Synchronet] / sbbs / smblib

Annotation of sbbs/smblib/smbstr.c, revision 1.1

1.1     ! root        1: /* smbstr.c */
        !             2: 
        !             3: /* Synchronet message base (SMB) library routines returning strings */
        !             4: 
        !             5: /* $Id: smbstr.c,v 1.7 2004/11/16 21:10:03 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 2004 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 <genwrap.h>           /* stricmp */
        !            39: #include "smblib.h"
        !            40: 
        !            41: char* SMBCALL smb_hfieldtype(ushort type)
        !            42: {
        !            43:        static char str[8];
        !            44: 
        !            45:        switch(type) {
        !            46:                case SENDER:                    return("Sender");
        !            47:                case SENDERAGENT:               return("SenderAgent");
        !            48:                case SENDERNETTYPE:             return("SenderNetType");
        !            49:                case SENDERNETADDR:             return("SenderNetAddr");
        !            50:                case SENDEREXT:                 return("SenderExt");
        !            51:                case SENDERORG:                 return("SenderOrg");
        !            52:                case SENDERIPADDR:              return("SenderIpAddr");
        !            53:                case SENDERHOSTNAME:    return("SenderHostName");
        !            54:                case SENDERPROTOCOL:    return("SenderProtocol");
        !            55:                case SENDERPORT:                return("SenderPort");
        !            56: 
        !            57:                case REPLYTO:                   return("ReplyTo");
        !            58:                case REPLYTOAGENT:              return("ReplyToAgent");
        !            59:                case REPLYTONETTYPE:    return("ReplyToNetType");
        !            60:                case REPLYTONETADDR:    return("ReplyToNetAddr");
        !            61:                case REPLYTOEXT:                return("ReplyToExt");
        !            62:                                                                
        !            63:                case RECIPIENT:                 return("Recipient");
        !            64:                case RECIPIENTAGENT:    return("RecipientAgent");
        !            65:                case RECIPIENTNETTYPE:  return("RecipientNetType");
        !            66:                case RECIPIENTNETADDR:  return("RecipientNetAddr");
        !            67:                case RECIPIENTEXT:              return("RecipientExt");
        !            68: 
        !            69:                case SUBJECT:                   return("Subject");
        !            70:                case SMB_SUMMARY:               return("Summary");
        !            71:                case SMB_COMMENT:               return("Comment");
        !            72:                case SMB_CARBONCOPY:    return("CarbonCopy");
        !            73:                case SMB_GROUP:                 return("Group");
        !            74:                case SMB_EXPIRATION:    return("Expiration");
        !            75:                case SMB_PRIORITY:              return("Priority");
        !            76:                case SMB_COST:                  return("Cost");
        !            77: 
        !            78:                case FIDOCTRL:                  return("FidoCtrl");
        !            79:                case FIDOAREA:                  return("FidoArea");
        !            80:                case FIDOSEENBY:                return("FidoSeenBy");
        !            81:                case FIDOPATH:                  return("FidoPath");
        !            82:                case FIDOMSGID:                 return("FidoMsgID");
        !            83:                case FIDOREPLYID:               return("FidoReplyID");
        !            84:                case FIDOPID:                   return("FidoPID");
        !            85:                case FIDOFLAGS:                 return("FidoFlags");
        !            86:                case FIDOTID:                   return("FidoTID");
        !            87: 
        !            88:                case RFC822HEADER:              return("RFC822Header");
        !            89:                case RFC822MSGID:               return("RFC822MsgID");
        !            90:                case RFC822REPLYID:             return("RFC822ReplyID");
        !            91:                case RFC822TO:                  return("RFC822To");
        !            92:                case RFC822FROM:                return("RFC822From");
        !            93:                case RFC822REPLYTO:             return("RFC822ReplyTo");
        !            94: 
        !            95:                case USENETPATH:                return("UsenetPath");
        !            96:                case USENETNEWSGROUPS:  return("UsenetNewsgroups");
        !            97: 
        !            98:                case SMTPCOMMAND:               return("SMTPCommand");
        !            99:                case SMTPREVERSEPATH:   return("SMTPReversePath");
        !           100: 
        !           101:                case SMTPSYSMSG:                return("SMTPSysMsg");
        !           102: 
        !           103:                case UNKNOWN:                   return("UNKNOWN");
        !           104:                case UNKNOWNASCII:              return("UNKNOWNASCII");
        !           105:                case UNUSED:                    return("UNUSED");
        !           106:        }
        !           107:        sprintf(str,"%02Xh",type);
        !           108:        return(str);
        !           109: }
        !           110: 
        !           111: ushort SMBCALL smb_hfieldtypelookup(const char* str)
        !           112: {
        !           113:        ushort type;
        !           114: 
        !           115:        if(isdigit(*str))
        !           116:                return((ushort)strtol(str,NULL,0));
        !           117: 
        !           118:        for(type=0;type<=UNUSED;type++)
        !           119:                if(stricmp(str,smb_hfieldtype(type))==0)
        !           120:                        return(type);
        !           121: 
        !           122:        return(UNKNOWN);
        !           123: }
        !           124: 
        !           125: char* SMBCALL smb_dfieldtype(ushort type)
        !           126: {
        !           127:        static char str[8];
        !           128: 
        !           129:        switch(type) {
        !           130:                case TEXT_BODY: return("TEXT_BODY");
        !           131:                case TEXT_TAIL: return("TEXT_TAIL");
        !           132:                case UNUSED:    return("UNUSED");
        !           133:        }
        !           134:        sprintf(str,"%02Xh",type);
        !           135:        return(str);
        !           136: }
        !           137: 
        !           138: char* SMBCALL smb_hashsourcetype(uchar type)
        !           139: {
        !           140:        static char str[8];
        !           141: 
        !           142:        switch(type) {
        !           143:                case SMB_HASH_SOURCE_BODY:              return(smb_dfieldtype(TEXT_BODY));
        !           144:                case SMB_HASH_SOURCE_MSG_ID:    return(smb_hfieldtype(RFC822MSGID));
        !           145:                case SMB_HASH_SOURCE_FTN_ID:    return(smb_hfieldtype(FIDOMSGID));
        !           146:        }
        !           147:        sprintf(str,"%02Xh",type);
        !           148:        return(str);
        !           149: }
        !           150: 
        !           151: char* SMBCALL smb_hashsource(smbmsg_t* msg, int source)
        !           152: {
        !           153:        switch(source) {
        !           154:                case SMB_HASH_SOURCE_MSG_ID:
        !           155:                        return(msg->id);
        !           156:                case SMB_HASH_SOURCE_FTN_ID:
        !           157:                        return(msg->ftn_msgid);
        !           158:        }
        !           159:        return("hash");
        !           160: }
        !           161: 
        !           162: /****************************************************************************/
        !           163: /* Converts when_t.zone into ASCII format                                   */
        !           164: /****************************************************************************/
        !           165: char* SMBCALL smb_zonestr(short zone, char* outstr)
        !           166: {
        !           167:        char*           plus;
        !           168:     static char str[32];
        !           169: 
        !           170:        switch((ushort)zone) {
        !           171:                case 0:     return("UTC");
        !           172:                case AST:   return("AST");
        !           173:                case EST:   return("EST");
        !           174:                case CST:   return("CST");
        !           175:                case MST:   return("MST");
        !           176:                case PST:   return("PST");
        !           177:                case YST:   return("YST");
        !           178:                case HST:   return("HST");
        !           179:                case BST:   return("BST");
        !           180:                case ADT:   return("ADT");
        !           181:                case EDT:   return("EDT");
        !           182:                case CDT:   return("CDT");
        !           183:                case MDT:   return("MDT");
        !           184:                case PDT:   return("PDT");
        !           185:                case YDT:   return("YDT");
        !           186:                case HDT:   return("HDT");
        !           187:                case BDT:   return("BDT");
        !           188:                case MID:   return("MID");
        !           189:                case VAN:   return("VAN");
        !           190:                case EDM:   return("EDM");
        !           191:                case WIN:   return("WIN");
        !           192:                case BOG:   return("BOG");
        !           193:                case CAR:   return("CAR");
        !           194:                case RIO:   return("RIO");
        !           195:                case FER:   return("FER");
        !           196:                case AZO:   return("AZO");
        !           197:                case LON:   return("LON");
        !           198:                case BER:   return("BER");
        !           199:                case ATH:   return("ATH");
        !           200:                case MOS:   return("MOS");
        !           201:                case DUB:   return("DUB");
        !           202:                case KAB:   return("KAB");
        !           203:                case KAR:   return("KAR");
        !           204:                case BOM:   return("BOM");
        !           205:                case KAT:   return("KAT");
        !           206:                case DHA:   return("DHA");
        !           207:                case BAN:   return("BAN");
        !           208:                case HON:   return("HON");
        !           209:                case TOK:   return("TOK");
        !           210:                case SYD:   return("SYD");
        !           211:                case NOU:   return("NOU");
        !           212:                case WEL:   return("WEL");
        !           213:                }
        !           214: 
        !           215:        if(!OTHER_ZONE(zone)) {
        !           216:                if(zone&(WESTERN_ZONE|US_ZONE)) /* West of UTC? */
        !           217:                        zone=-(zone&0xfff);
        !           218:                else
        !           219:                        zone&=0xfff;
        !           220:        }
        !           221: 
        !           222:        if(zone>0)
        !           223:                plus="+";
        !           224:        else
        !           225:                plus="";
        !           226:        sprintf(str,"UTC%s%d:%02u", plus, zone/60, zone<0 ? (-zone)%60 : zone%60);
        !           227: 
        !           228:        if(outstr==NULL)
        !           229:                return(str);
        !           230:        strcpy(outstr,str);
        !           231:        return(outstr);
        !           232: }
        !           233: 
        !           234: /****************************************************************************/
        !           235: /* Returns an ASCII string for FidoNet address 'addr'                       */
        !           236: /****************************************************************************/
        !           237: char* SMBCALL smb_faddrtoa(fidoaddr_t* addr, char* outstr)
        !           238: {
        !           239:        static char str[64];
        !           240:     char point[25];
        !           241: 
        !           242:        if(addr==NULL)
        !           243:                return("0:0/0");
        !           244:        sprintf(str,"%hu:%hu/%hu",addr->zone,addr->net,addr->node);
        !           245:        if(addr->point) {
        !           246:                sprintf(point,".%hu",addr->point);
        !           247:                strcat(str,point); 
        !           248:        }
        !           249:        if(outstr==NULL)
        !           250:                return(str);
        !           251:        strcpy(outstr,str);
        !           252:        return(outstr);
        !           253: }
        !           254: 
        !           255: /****************************************************************************/
        !           256: /* Returns the FidoNet address parsed from str.                                                                */
        !           257: /****************************************************************************/
        !           258: fidoaddr_t SMBCALL smb_atofaddr(const fidoaddr_t* sys_addr, const char *str)
        !           259: {
        !           260:        char *p;
        !           261:        fidoaddr_t addr;
        !           262:        fidoaddr_t tmp_addr={1,1,1,0};  /* Default system address: 1:1/1.0 */
        !           263: 
        !           264:        if(sys_addr==NULL)
        !           265:                sys_addr=&tmp_addr;
        !           266: 
        !           267:        ZERO_VAR(addr);
        !           268:        if((p=strchr(str,':'))!=NULL) {
        !           269:                addr.zone=atoi(str);
        !           270:                addr.net=atoi(p+1); 
        !           271:        } else {
        !           272:                addr.zone=sys_addr->zone;
        !           273:                addr.net=atoi(str);
        !           274:        }
        !           275:        if(addr.zone==0)              /* no such thing as zone 0 */
        !           276:                addr.zone=1;
        !           277:        if((p=strchr(str,'/'))!=NULL)
        !           278:                addr.node=atoi(p+1);
        !           279:        else {
        !           280:                if(addr.zone==sys_addr->zone)
        !           281:                        addr.net=sys_addr->net;
        !           282:                addr.node=atoi(str); 
        !           283:        }
        !           284:        if((p=strchr(str,'.'))!=NULL)
        !           285:                addr.point=atoi(p+1);
        !           286:        return(addr);
        !           287: }
        !           288: 
        !           289: /****************************************************************************/
        !           290: /* Returns ASCIIZ representation of network address (net_t)                                    */
        !           291: /****************************************************************************/
        !           292: char* SMBCALL smb_netaddr(net_t* net)
        !           293: {
        !           294:        if(net->type==NET_FIDO)
        !           295:                return(smb_faddrtoa((fidoaddr_t*)net->addr,NULL));
        !           296:        return(net->addr);
        !           297: }
        !           298: 
        !           299: /****************************************************************************/
        !           300: /* Returns net_type for passed e-mail address (i.e. "user@addr")                       */
        !           301: /****************************************************************************/
        !           302: ushort SMBCALL smb_netaddr_type(const char* str)
        !           303: {
        !           304:        char*   p;
        !           305:        char*   tp;
        !           306: 
        !           307:        if((p=strchr(str,'@'))==NULL)
        !           308:                return(NET_NONE);
        !           309: 
        !           310:        p++;
        !           311:        SKIP_WHITESPACE(p);
        !           312:        if(*p==0)
        !           313:                return(NET_UNKNOWN);
        !           314: 
        !           315:        if(isalpha(*p) && strchr(p,'.')==NULL)
        !           316:                return(NET_QWK);
        !           317: 
        !           318:        for(tp=p;*tp;tp++) {
        !           319:                if(!isdigit(*tp) && *tp!=':' && *tp!='/' && *tp!='.')
        !           320:                        break;
        !           321:        }
        !           322:        if(isdigit(*p) && *tp)
        !           323:                return(NET_FIDO);
        !           324:        if(isalnum(*p))
        !           325:                return(NET_INTERNET);
        !           326: 
        !           327:        return(NET_UNKNOWN);
        !           328: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.