Return to data_ovl.c CVS log

Up to [Synchronet] / sbbs / sbbs2

Annotation of sbbs/sbbs2/data_ovl.c, revision 1.1

1.1     ! root        1: #line 1 "DATA_OVL.C"
        !             2: 
        !             3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
        !             4: 
        !             5: #include "sbbs.h"
        !             6: 
        !             7: /****************************************************************************/
        !             8: /* Writes into user.number's slot in USER.DAT data in structure 'user'      */
        !             9: /* Called from functions newuser, useredit and main                         */
        !            10: /****************************************************************************/
        !            11: void putuserdat(user_t user)
        !            12: {
        !            13:     int i,file;
        !            14:     char userdat[U_LEN+1],str[U_LEN+1];
        !            15:     node_t node;
        !            16: 
        !            17: if(!user.number) {
        !            18:     errormsg(WHERE,ERR_CHK,"user number",0);
        !            19:     return; }
        !            20: memset(userdat,ETX,U_LEN);
        !            21: putrec(userdat,U_ALIAS,LEN_ALIAS+5,user.alias);
        !            22: putrec(userdat,U_NAME,LEN_NAME,user.name);
        !            23: putrec(userdat,U_HANDLE,LEN_HANDLE,user.handle);
        !            24: putrec(userdat,U_HANDLE+LEN_HANDLE,2,crlf);
        !            25: 
        !            26: putrec(userdat,U_NOTE,LEN_NOTE,user.note);
        !            27: putrec(userdat,U_COMP,LEN_COMP,user.comp);
        !            28: putrec(userdat,U_COMP+LEN_COMP,2,crlf);
        !            29: 
        !            30: putrec(userdat,U_COMMENT,LEN_COMMENT,user.comment);
        !            31: putrec(userdat,U_COMMENT+LEN_COMMENT,2,crlf);
        !            32: 
        !            33: putrec(userdat,U_NETMAIL,LEN_NETMAIL,user.netmail);
        !            34: putrec(userdat,U_NETMAIL+LEN_NETMAIL,2,crlf);
        !            35: 
        !            36: putrec(userdat,U_ADDRESS,LEN_ADDRESS,user.address);
        !            37: putrec(userdat,U_LOCATION,LEN_LOCATION,user.location);
        !            38: putrec(userdat,U_ZIPCODE,LEN_ZIPCODE,user.zipcode);
        !            39: putrec(userdat,U_ZIPCODE+LEN_ZIPCODE,2,crlf);
        !            40: 
        !            41: putrec(userdat,U_PASS,LEN_PASS,user.pass);
        !            42: putrec(userdat,U_PHONE,LEN_PHONE,user.phone);
        !            43: putrec(userdat,U_BIRTH,LEN_BIRTH,user.birth);
        !            44: putrec(userdat,U_MODEM,LEN_MODEM,user.modem);
        !            45: putrec(userdat,U_LASTON,8,ultoa(user.laston,str,16));
        !            46: putrec(userdat,U_FIRSTON,8,ultoa(user.firston,str,16));
        !            47: putrec(userdat,U_EXPIRE,8,ultoa(user.expire,str,16));
        !            48: putrec(userdat,U_PWMOD,8,ultoa(user.pwmod,str,16));
        !            49: putrec(userdat,U_PWMOD+8,2,crlf);
        !            50: 
        !            51: putrec(userdat,U_LOGONS,5,itoa(user.logons,str,10));
        !            52: putrec(userdat,U_LTODAY,5,itoa(user.ltoday,str,10));
        !            53: putrec(userdat,U_TIMEON,5,itoa(user.timeon,str,10));
        !            54: putrec(userdat,U_TEXTRA,5,itoa(user.textra,str,10));
        !            55: putrec(userdat,U_TTODAY,5,itoa(user.ttoday,str,10));
        !            56: putrec(userdat,U_TLAST,5,itoa(user.tlast,str,10));
        !            57: putrec(userdat,U_POSTS,5,itoa(user.posts,str,10));
        !            58: putrec(userdat,U_EMAILS,5,itoa(user.emails,str,10));
        !            59: putrec(userdat,U_FBACKS,5,itoa(user.fbacks,str,10));
        !            60: putrec(userdat,U_ETODAY,5,itoa(user.etoday,str,10));
        !            61: putrec(userdat,U_PTODAY,5,itoa(user.ptoday,str,10));
        !            62: putrec(userdat,U_PTODAY+5,2,crlf);
        !            63: 
        !            64: putrec(userdat,U_ULB,10,ultoa(user.ulb,str,10));
        !            65: putrec(userdat,U_ULS,5,itoa(user.uls,str,10));
        !            66: putrec(userdat,U_DLB,10,ultoa(user.dlb,str,10));
        !            67: putrec(userdat,U_DLS,5,itoa(user.dls,str,10));
        !            68: putrec(userdat,U_CDT,10,ultoa(user.cdt,str,10));
        !            69: putrec(userdat,U_MIN,10,ultoa(user.min,str,10));
        !            70: putrec(userdat,U_MIN+10,2,crlf);
        !            71: 
        !            72: putrec(userdat,U_LEVEL,2,itoa(user.level,str,10));
        !            73: putrec(userdat,U_FLAGS1,8,ultoa(user.flags1,str,16));
        !            74: putrec(userdat,U_TL,2,nulstr); /* unused */
        !            75: putrec(userdat,U_FLAGS2,8,ultoa(user.flags2,str,16));
        !            76: putrec(userdat,U_EXEMPT,8,ultoa(user.exempt,str,16));
        !            77: putrec(userdat,U_REST,8,ultoa(user.rest,str,16));
        !            78: putrec(userdat,U_REST+8,2,crlf);
        !            79: 
        !            80: putrec(userdat,U_ROWS,2,itoa(user.rows,str,10));
        !            81: userdat[U_SEX]=user.sex;
        !            82: userdat[U_PROT]=user.prot;
        !            83: putrec(userdat,U_MISC,8,ultoa(user.misc,str,16));
        !            84: putrec(userdat,U_LEECH,2,itoa(user.leech,str,16));
        !            85: 
        !            86: putrec(userdat,U_CURSUB,8,user.cursub);
        !            87: putrec(userdat,U_CURDIR,8,user.curdir);
        !            88: 
        !            89: // putrec(userdat,U_CMDSET,2,itoa(user.cmdset,str,16)); /* Unused */
        !            90: putrec(userdat,U_CMDSET+2,2,crlf);
        !            91: 
        !            92: putrec(userdat,U_XFER_CMD+LEN_XFER_CMD,2,crlf);
        !            93: 
        !            94: putrec(userdat,U_MAIL_CMD+LEN_MAIL_CMD,2,crlf);
        !            95: 
        !            96: putrec(userdat,U_FREECDT,10,ultoa(user.freecdt,str,10));
        !            97: 
        !            98: putrec(userdat,U_FLAGS3,8,ultoa(user.flags3,str,16));
        !            99: putrec(userdat,U_FLAGS4,8,ultoa(user.flags4,str,16));
        !           100: 
        !           101: if(user.xedit)
        !           102:        putrec(userdat,U_XEDIT,8,xedit[user.xedit-1]->code);
        !           103: else
        !           104:        putrec(userdat,U_XEDIT,8,nulstr);
        !           105: 
        !           106: putrec(userdat,U_SHELL,8,shell[user.shell]->code);
        !           107: 
        !           108: putrec(userdat,U_QWK,8,ultoa(user.qwk,str,16));
        !           109: putrec(userdat,U_TMPEXT,3,user.tmpext);
        !           110: putrec(userdat,U_CHAT,8,ultoa(user.chat,str,16));
        !           111: putrec(userdat,U_NS_TIME,8,ultoa(user.ns_time,str,16));
        !           112: 
        !           113: putrec(userdat,U_UNUSED,29,crlf);
        !           114: putrec(userdat,U_UNUSED+29,2,crlf);
        !           115: 
        !           116: sprintf(str,"%sUSER\\USER.DAT",data_dir);
        !           117: if((file=nopen(str,O_WRONLY|O_CREAT|O_DENYNONE))==-1) {
        !           118:        errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_DENYNONE);
        !           119:        return; }
        !           120: 
        !           121: /***           This shouldn't be necessary
        !           122: if(filelength(file)<(long)((long)user.number*U_LEN))
        !           123:     lseek(file,0L,SEEK_END);
        !           124: else
        !           125: ***/
        !           126: 
        !           127: lseek(file,(long)((long)((long)user.number-1)*U_LEN),SEEK_SET);
        !           128: 
        !           129: i=0;
        !           130: while(i<LOOP_NODEDAB
        !           131:        && lock(file,(long)((long)(user.number-1)*U_LEN),U_LEN)==-1) {
        !           132:        if(i>10)
        !           133:                mswait(55);
        !           134:        i++; }
        !           135: 
        !           136: if(i>=LOOP_NODEDAB) {
        !           137:        close(file);
        !           138:        errormsg(WHERE,ERR_LOCK,"USER.DAT",user.number);
        !           139:     return; }
        !           140: 
        !           141: if(write(file,userdat,U_LEN)!=U_LEN) {
        !           142:        unlock(file,(long)((long)(user.number-1)*U_LEN),U_LEN);
        !           143:     close(file);
        !           144:     errormsg(WHERE,ERR_WRITE,str,U_LEN);
        !           145:     return; }
        !           146: unlock(file,(long)((long)(user.number-1)*U_LEN),U_LEN);
        !           147: close(file);
        !           148: for(i=1;i<=sys_nodes;i++) { /* instant user data update */
        !           149:     if(i==node_num)
        !           150:         continue;
        !           151:     getnodedat(i,&node,0);
        !           152:     if(node.useron==user.number && (node.status==NODE_INUSE
        !           153:         || node.status==NODE_QUIET)) {
        !           154:         getnodedat(i,&node,1);
        !           155:         node.misc|=NODE_UDAT;
        !           156:         putnodedat(i,node);
        !           157:         break; } }
        !           158: }
        !           159: 
        !           160: 
        !           161: /****************************************************************************/
        !           162: /* Puts 'name' into slot 'number' in USER\\NAME.DAT                                                    */
        !           163: /****************************************************************************/
        !           164: void putusername(int number, char *name)
        !           165: {
        !           166:        char str[256];
        !           167:        int file;
        !           168:        long length,l;
        !           169: 
        !           170: sprintf(str,"%sUSER\\NAME.DAT",data_dir);
        !           171: if((file=nopen(str,O_RDWR|O_CREAT))==-1) {
        !           172:        errormsg(WHERE,ERR_OPEN,str,O_RDWR|O_CREAT);
        !           173:        return; }
        !           174: length=filelength(file);
        !           175: if(length && length%(LEN_ALIAS+2)) {
        !           176:        close(file);
        !           177:        errormsg(WHERE,ERR_LEN,str,length);
        !           178:        return; }
        !           179: if(length<(((long)number-1)*(LEN_ALIAS+2))) {
        !           180:        sprintf(str,"%*s",LEN_ALIAS,nulstr);
        !           181:        strset(str,ETX);
        !           182:        strcat(str,crlf);
        !           183:        lseek(file,0L,SEEK_END);
        !           184:        while(filelength(file)<((long)number*(LEN_ALIAS+2)))
        !           185:                write(file,str,(LEN_ALIAS+2)); }
        !           186: lseek(file,(long)(((long)number-1)*(LEN_ALIAS+2)),SEEK_SET);
        !           187: putrec(str,0,LEN_ALIAS,name);
        !           188: putrec(str,LEN_ALIAS,2,crlf);
        !           189: write(file,str,LEN_ALIAS+2);
        !           190: close(file);
        !           191: }
        !           192: 
        !           193: /****************************************************************************/
        !           194: /* Fills the 'ptr' element of the each element of the sub[] array of sub_t  */
        !           195: /* and the sub_misc and sub_ptr global variables                            */
        !           196: /* Called from function main                                                */
        !           197: /****************************************************************************/
        !           198: void getmsgptrs()
        !           199: {
        !           200:        char    str[256];
        !           201:        ushort  ch;
        !           202:        uint    i;
        !           203:        int     file;
        !           204:        long    length;
        !           205:        FILE    *stream;
        !           206: 
        !           207: now=time(NULL);
        !           208: if(!useron.number)
        !           209:     return;
        !           210: bputs(text[LoadingMsgPtrs]);
        !           211: sprintf(str,"%sUSER\\PTRS\\%4.4u.IXB",data_dir,useron.number);
        !           212: if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
        !           213:        for(i=0;i<total_subs;i++) {
        !           214:                sub_ptr[i]=sub[i]->ptr=sub_last[i]=sub[i]->last=0;
        !           215:                if(sub[i]->misc&SUB_NSDEF)
        !           216:                        sub[i]->misc|=SUB_NSCAN;
        !           217:                else
        !           218:                        sub[i]->misc&=~SUB_NSCAN;
        !           219:                if(sub[i]->misc&SUB_SSDEF)
        !           220:                        sub[i]->misc|=SUB_SSCAN;
        !           221:                else
        !           222:                        sub[i]->misc&=~SUB_SSCAN;
        !           223:                sub_misc[i]=sub[i]->misc; }
        !           224:        bputs(text[LoadedMsgPtrs]);
        !           225:        return; }
        !           226: length=filelength(file);
        !           227: for(i=0;i<total_subs;i++) {
        !           228:        if(length<(sub[i]->ptridx+1)*10L) {
        !           229:                sub[i]->ptr=sub[i]->last=0L;
        !           230:                if(sub[i]->misc&SUB_NSDEF)
        !           231:                        sub[i]->misc|=SUB_NSCAN;
        !           232:                else
        !           233:                        sub[i]->misc&=~SUB_NSCAN;
        !           234:                if(sub[i]->misc&SUB_SSDEF)
        !           235:                        sub[i]->misc|=SUB_SSCAN;
        !           236:                else
        !           237:                        sub[i]->misc&=~SUB_SSCAN; }
        !           238:        else {
        !           239:                fseek(stream,(long)sub[i]->ptridx*10L,SEEK_SET);
        !           240:                fread(&sub[i]->ptr,4,1,stream);
        !           241:                fread(&sub[i]->last,4,1,stream);
        !           242:                fread(&ch,2,1,stream);
        !           243:                if(ch&5)        /* Either bit 0 or 2 */
        !           244:                        sub[i]->misc|=SUB_NSCAN;
        !           245:                else
        !           246:                        sub[i]->misc&=~SUB_NSCAN;
        !           247:                if(ch&2)
        !           248:                        sub[i]->misc|=SUB_SSCAN;
        !           249:                else
        !           250:                        sub[i]->misc&=~SUB_SSCAN;
        !           251:                if(ch&0x100)
        !           252:                        sub[i]->misc|=SUB_YSCAN;
        !           253:                else
        !           254:                        sub[i]->misc&=~SUB_YSCAN; }
        !           255:        sub_ptr[i]=sub[i]->ptr;
        !           256:        sub_last[i]=sub[i]->last;
        !           257:     sub_misc[i]=sub[i]->misc; }
        !           258: fclose(stream);
        !           259: bputs(text[LoadedMsgPtrs]);
        !           260: }
        !           261: 
        !           262: /****************************************************************************/
        !           263: /* Writes to DATA\USER\PTRS\xxxx.DAB the msgptr array for the current user     */
        !           264: /* Called from functions main and newuser                                   */
        !           265: /****************************************************************************/
        !           266: void putmsgptrs()
        !           267: {
        !           268:        char    str[256];
        !           269:        ushort  idx,ch;
        !           270:        uint    i,j;
        !           271:        int     file;
        !           272:        ulong   l=0L,length;
        !           273: 
        !           274: if(!useron.number)
        !           275:     return;
        !           276: sprintf(str,"%sUSER\\PTRS\\%4.4u.IXB",data_dir,useron.number);
        !           277: if((file=nopen(str,O_WRONLY|O_CREAT))==-1) {
        !           278:        errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT);
        !           279:        return; }
        !           280: length=filelength(file);
        !           281: for(i=0;i<total_subs;i++) {
        !           282:        if(sub[i]->ptr==sub_ptr[i] && sub[i]->last==sub_last[i]
        !           283:                && length>=((long)(sub[i]->ptridx+1)*10)
        !           284:                && ((sub[i]->misc&(SUB_NSCAN|SUB_SSCAN|SUB_YSCAN))
        !           285:                        ==(sub_misc[i]&(SUB_NSCAN|SUB_SSCAN|SUB_YSCAN))))
        !           286:         continue;
        !           287:        while(filelength(file)<(long)(sub[i]->ptridx)*10) {
        !           288:         lseek(file,0L,SEEK_END);
        !           289:                idx=tell(file)/10;
        !           290:                for(j=0;j<total_subs;j++)
        !           291:                        if(sub[j]->ptridx==idx)
        !           292:                                break;
        !           293:         write(file,&l,4);
        !           294:         write(file,&l,4);
        !           295:                ch=0xff;                                        /* default to scan ON for new sub */
        !           296:                if(j<total_subs) {
        !           297:                        if(!(sub[j]->misc&SUB_NSCAN))
        !           298:                                ch&=~5;
        !           299:                        if(!(sub[j]->misc&SUB_SSCAN))
        !           300:                                ch&=~2;
        !           301:                        if(sub[j]->misc&SUB_YSCAN)
        !           302:                                ch|=0x100; }
        !           303:                write(file,&ch,2); }
        !           304:        lseek(file,(long)((long)(sub[i]->ptridx)*10),SEEK_SET);
        !           305:     write(file,&(sub[i]->ptr),4);
        !           306:        write(file,&(sub[i]->last),4);
        !           307:        ch=0xff;
        !           308:        if(!(sub[i]->misc&SUB_NSCAN))
        !           309:                ch&=~5;
        !           310:        if(!(sub[i]->misc&SUB_SSCAN))
        !           311:                ch&=~2;
        !           312:        if(sub[i]->misc&SUB_YSCAN)
        !           313:                ch|=0x100;
        !           314:        write(file,&ch,2); }
        !           315: close(file);
        !           316: if(!flength(str))                              /* Don't leave 0 byte files */
        !           317:        remove(str);
        !           318: }
        !           319: 
        !           320: /****************************************************************************/
        !           321: /* Checks for a duplicate user filed starting at user record offset         */
        !           322: /* 'offset', reading in 'datlen' chars, comparing to 'str' for each user    */
        !           323: /* except 'usernumber' if it is non-zero. Comparison is NOT case sensitive. */
        !           324: /* del is 1 if the search is to included deleted/inactive users 0 otherwise */
        !           325: /* Returns the usernumber of the dupe if found, 0 if not                    */
        !           326: /****************************************************************************/
        !           327: uint userdatdupe(uint usernumber, uint offset, uint datlen, char *dat
        !           328:     , char del)
        !           329: {
        !           330:     char str[256];
        !           331:     int i,file;
        !           332:     long l,length;
        !           333: 
        !           334: truncsp(dat);
        !           335: sprintf(str,"%sUSER\\USER.DAT",data_dir);
        !           336: if((file=nopen(str,O_RDONLY|O_DENYNONE))==-1)
        !           337:     return(0);
        !           338: length=filelength(file);
        !           339: bputs(text[SearchingForDupes]);
        !           340: for(l=0;l<length && online;l+=U_LEN) {
        !           341:        checkline();
        !           342:     if(usernumber && l/U_LEN==usernumber-1)
        !           343:         continue;
        !           344:     lseek(file,l+offset,SEEK_SET);
        !           345:        i=0;
        !           346:        while(i<LOOP_NODEDAB && lock(file,l,U_LEN)==-1) {
        !           347:                if(i>10)
        !           348:                        mswait(55);
        !           349:                i++; }
        !           350: 
        !           351:        if(i>=LOOP_NODEDAB) {
        !           352:                close(file);
        !           353:                errormsg(WHERE,ERR_LOCK,"USER.DAT",l);
        !           354:                return(0); }
        !           355: 
        !           356:     read(file,str,datlen);
        !           357:     for(i=0;i<datlen;i++)
        !           358:         if(str[i]==ETX) break;
        !           359:     str[i]=0;
        !           360:     truncsp(str);
        !           361:     if(!stricmp(str,dat)) {
        !           362:         if(!del) {      /* Don't include deleted users in search */
        !           363:             lseek(file,l+U_MISC,SEEK_SET);
        !           364:             read(file,str,8);
        !           365:             getrec(str,0,8,str);
        !           366:                        if(ahtoul(str)&(DELETED|INACTIVE)) {
        !           367:                                unlock(file,l,U_LEN);
        !           368:                                continue; } }
        !           369:                unlock(file,l,U_LEN);
        !           370:         close(file);
        !           371:         bputs(text[SearchedForDupes]);
        !           372:                return((l/U_LEN)+1); }
        !           373:        else
        !           374:                unlock(file,l,U_LEN); }
        !           375: close(file);
        !           376: bputs(text[SearchedForDupes]);
        !           377: return(0);
        !           378: }
        !           379: 
        !           380: 
        !           381: /****************************************************************************/
        !           382: /* Removes any files in the user transfer index (XFER.IXT) that match the   */
        !           383: /* specifications of dest, or source user, or filename or any combination.  */
        !           384: /****************************************************************************/
        !           385: void rmuserxfers(int fromuser, int destuser, char *fname)
        !           386: {
        !           387:     char str[256],*ixtbuf;
        !           388:     int file;
        !           389:     long l,length;
        !           390: 
        !           391: sprintf(str,"%sXFER.IXT",data_dir);
        !           392: if(!fexist(str))
        !           393:     return;
        !           394: if(!flength(str)) {
        !           395:     remove(str);
        !           396:     return; }
        !           397: if((file=nopen(str,O_RDONLY))==-1) {
        !           398:     errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
        !           399:     return; }
        !           400: length=filelength(file);
        !           401: if((ixtbuf=(char *)MALLOC(length))==NULL) {
        !           402:     close(file);
        !           403:     errormsg(WHERE,ERR_ALLOC,str,length);
        !           404:     return; }
        !           405: if(read(file,ixtbuf,length)!=length) {
        !           406:     close(file);
        !           407:        FREE(ixtbuf);
        !           408:     errormsg(WHERE,ERR_READ,str,length);
        !           409:     return; }
        !           410: close(file);
        !           411: if((file=nopen(str,O_WRONLY|O_TRUNC))==-1) {
        !           412:        FREE(ixtbuf);
        !           413:     errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_TRUNC);
        !           414:     return; }
        !           415: for(l=0;l<length;l+=24) {
        !           416:     if(fname!=NULL && fname[0]) {               /* fname specified */
        !           417:         if(!strncmp(ixtbuf+l+5,fname,12)) {     /* this is the file */
        !           418:             if(destuser && fromuser) {          /* both dest and from user */
        !           419:                 if(atoi(ixtbuf+l)==destuser && atoi(ixtbuf+l+18)==fromuser)
        !           420:                     continue; }                 /* both match */
        !           421:             else if(fromuser) {                 /* from user */
        !           422:                 if(atoi(ixtbuf+l+18)==fromuser) /* matches */
        !           423:                     continue; }
        !           424:             else if(destuser) {                 /* dest user */
        !           425:                 if(atoi(ixtbuf+l)==destuser)    /* matches */
        !           426:                     continue; }
        !           427:             else continue; } }                  /* no users, so match */
        !           428:     else if(destuser && fromuser) {
        !           429:         if(atoi(ixtbuf+l+18)==fromuser && atoi(ixtbuf+l)==destuser)
        !           430:             continue; }
        !           431:     else if(destuser && atoi(ixtbuf+l)==destuser)
        !           432:         continue;
        !           433:     else if(fromuser && atoi(ixtbuf+l+18)==fromuser)
        !           434:         continue;
        !           435:     write(file,ixtbuf+l,24); }
        !           436: close(file);
        !           437: FREE(ixtbuf);
        !           438: }
        !           439: 

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