![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to filedat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3|
Return to filedat.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 ! root 1: /* filedat.c */ ! 2: ! 3: /* Synchronet file database-related exported functions */ ! 4: ! 5: /* $Id: filedat.c,v 1.27 2006/12/29 08:41:50 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 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: ! 40: /****************************************************************************/ ! 41: /* Gets filedata from dircode.DAT file */ ! 42: /* Need fields .name ,.dir and .offset to get other info */ ! 43: /* Does not fill .dateuled or .datedled fields. */ ! 44: /****************************************************************************/ ! 45: BOOL DLLCALL getfiledat(scfg_t* cfg, file_t* f) ! 46: { ! 47: char buf[F_LEN+1],str[MAX_PATH+1]; ! 48: int file; ! 49: long length; ! 50: ! 51: SAFEPRINTF2(str,"%s%s.dat",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 52: if((file=sopen(str,O_RDONLY|O_BINARY,SH_DENYWR))==-1) { ! 53: return(FALSE); ! 54: } ! 55: length=filelength(file); ! 56: if(f->datoffset>length) { ! 57: close(file); ! 58: return(FALSE); ! 59: } ! 60: if(length%F_LEN) { ! 61: close(file); ! 62: return(FALSE); ! 63: } ! 64: lseek(file,f->datoffset,SEEK_SET); ! 65: if(read(file,buf,F_LEN)!=F_LEN) { ! 66: close(file); ! 67: return(FALSE); ! 68: } ! 69: close(file); ! 70: getrec(buf,F_ALTPATH,2,str); ! 71: f->altpath=hptoi(str); ! 72: getrec(buf,F_CDT,LEN_FCDT,str); ! 73: f->cdt=atol(str); ! 74: ! 75: if(!f->size) { /* only read disk if this is null */ ! 76: getfilepath(cfg,f,str); ! 77: f->size=flength(str); ! 78: f->date=fdate(str); ! 79: /* ! 80: } ! 81: else { ! 82: f->size=f->cdt; ! 83: f->date=0; } ! 84: */ ! 85: } ! 86: #if 0 ! 87: if((f->size>0L) && cur_cps) ! 88: f->timetodl=(ushort)(f->size/(ulong)cur_cps); ! 89: else ! 90: #endif ! 91: f->timetodl=0; ! 92: ! 93: getrec(buf,F_DESC,LEN_FDESC,f->desc); ! 94: getrec(buf,F_ULER,LEN_ALIAS,f->uler); ! 95: getrec(buf,F_TIMESDLED,5,str); ! 96: f->timesdled=atoi(str); ! 97: getrec(buf,F_OPENCOUNT,3,str); ! 98: f->opencount=atoi(str); ! 99: if(buf[F_MISC]!=ETX) ! 100: f->misc=buf[F_MISC]-' '; ! 101: else ! 102: f->misc=0; ! 103: return(TRUE); ! 104: } ! 105: ! 106: /****************************************************************************/ ! 107: /* Puts filedata into DIR_code.DAT file */ ! 108: /* Called from removefiles */ ! 109: /****************************************************************************/ ! 110: BOOL DLLCALL putfiledat(scfg_t* cfg, file_t* f) ! 111: { ! 112: char buf[F_LEN+1],str[MAX_PATH+1],tmp[128]; ! 113: int file; ! 114: long length; ! 115: ! 116: putrec(buf,F_CDT,LEN_FCDT,ultoa(f->cdt,tmp,10)); ! 117: putrec(buf,F_DESC,LEN_FDESC,f->desc); ! 118: putrec(buf,F_DESC+LEN_FDESC,2,crlf); ! 119: putrec(buf,F_ULER,LEN_ALIAS+5,f->uler); ! 120: putrec(buf,F_ULER+LEN_ALIAS+5,2,crlf); ! 121: putrec(buf,F_TIMESDLED,5,ultoa(f->timesdled,tmp,10)); ! 122: putrec(buf,F_TIMESDLED+5,2,crlf); ! 123: putrec(buf,F_OPENCOUNT,3,ultoa(f->opencount,tmp,10)); ! 124: putrec(buf,F_OPENCOUNT+3,2,crlf); ! 125: buf[F_MISC]=f->misc+' '; ! 126: putrec(buf,F_ALTPATH,2,hexplus(f->altpath,tmp)); ! 127: putrec(buf,F_ALTPATH+2,2,crlf); ! 128: SAFEPRINTF2(str,"%s%s.dat",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 129: if((file=sopen(str,O_WRONLY|O_BINARY,SH_DENYRW))==-1) { ! 130: return(FALSE); ! 131: } ! 132: length=filelength(file); ! 133: if(length%F_LEN) { ! 134: close(file); ! 135: return(FALSE); ! 136: } ! 137: if(f->datoffset>length) { ! 138: close(file); ! 139: return(FALSE); ! 140: } ! 141: lseek(file,f->datoffset,SEEK_SET); ! 142: if(write(file,buf,F_LEN)!=F_LEN) { ! 143: close(file); ! 144: return(FALSE); ! 145: } ! 146: length=filelength(file); ! 147: close(file); ! 148: if(length%F_LEN) { ! 149: return(FALSE); ! 150: } ! 151: return(TRUE); ! 152: } ! 153: ! 154: /****************************************************************************/ ! 155: /* Adds the data for struct filedat to the directory's data base. */ ! 156: /* changes the .datoffset field only */ ! 157: /* returns 1 if added successfully, 0 if not. */ ! 158: /****************************************************************************/ ! 159: BOOL DLLCALL addfiledat(scfg_t* cfg, file_t* f) ! 160: { ! 161: char str[MAX_PATH+1],fname[13],c,fdat[F_LEN+1]; ! 162: char tmp[128]; ! 163: uchar *ixbbuf,idx[3]; ! 164: int i,file; ! 165: long l,length; ! 166: time_t now; ! 167: time_t uldate; ! 168: ! 169: /************************/ ! 170: /* Add data to DAT File */ ! 171: /************************/ ! 172: SAFEPRINTF2(str,"%s%s.dat",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 173: if((file=sopen(str,O_RDWR|O_BINARY|O_CREAT,SH_DENYRW,S_IREAD|S_IWRITE))==-1) { ! 174: return(FALSE); ! 175: } ! 176: length=filelength(file); ! 177: if(length==0L) ! 178: l=0L; ! 179: else { ! 180: if(length%F_LEN) { ! 181: close(file); ! 182: return(FALSE); ! 183: } ! 184: for(l=0;l<length;l+=F_LEN) { /* Find empty slot */ ! 185: lseek(file,l,SEEK_SET); ! 186: read(file,&c,1); ! 187: if(c==ETX) break; ! 188: } ! 189: if(l/F_LEN>=MAX_FILES || l/F_LEN>=cfg->dir[f->dir]->maxfiles) { ! 190: close(file); ! 191: return(FALSE); ! 192: } ! 193: } ! 194: putrec(fdat,F_CDT,LEN_FCDT,ultoa(f->cdt,tmp,10)); ! 195: putrec(fdat,F_DESC,LEN_FDESC,f->desc); ! 196: putrec(fdat,F_DESC+LEN_FDESC,2,crlf); ! 197: putrec(fdat,F_ULER,LEN_ALIAS+5,f->uler); ! 198: putrec(fdat,F_ULER+LEN_ALIAS+5,2,crlf); ! 199: putrec(fdat,F_TIMESDLED,5,ultoa(f->timesdled,tmp,10)); ! 200: putrec(fdat,F_TIMESDLED+5,2,crlf); ! 201: putrec(fdat,F_OPENCOUNT,3,ultoa(f->opencount,tmp,10)); ! 202: putrec(fdat,F_OPENCOUNT+3,2,crlf); ! 203: fdat[F_MISC]=f->misc+' '; ! 204: putrec(fdat,F_ALTPATH,2,hexplus(f->altpath,tmp)); ! 205: putrec(fdat,F_ALTPATH+2,2,crlf); ! 206: f->datoffset=l; ! 207: idx[0]=(uchar)(l&0xff); /* Get offset within DAT file for IXB file */ ! 208: idx[1]=(uchar)((l>>8)&0xff); ! 209: idx[2]=(uchar)((l>>16)&0xff); ! 210: lseek(file,l,SEEK_SET); ! 211: if(write(file,fdat,F_LEN)!=F_LEN) { ! 212: close(file); ! 213: return(FALSE); ! 214: } ! 215: length=filelength(file); ! 216: close(file); ! 217: if(length%F_LEN) { ! 218: return(FALSE); ! 219: } ! 220: ! 221: /*******************************************/ ! 222: /* Update last upload date/time stamp file */ ! 223: /*******************************************/ ! 224: SAFEPRINTF2(str,"%s%s.dab",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 225: if((file=sopen(str,O_WRONLY|O_CREAT|O_BINARY,SH_DENYRW,S_IREAD|S_IWRITE))!=-1) { ! 226: now=time(NULL); ! 227: write(file,&now,4); ! 228: close(file); ! 229: } ! 230: ! 231: /************************/ ! 232: /* Add data to IXB File */ ! 233: /************************/ ! 234: SAFECOPY(fname,f->name); ! 235: for(i=8;i<12;i++) /* Turn FILENAME.EXT into FILENAMEEXT */ ! 236: fname[i]=fname[i+1]; ! 237: SAFEPRINTF2(str,"%s%s.ixb",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 238: if((file=sopen(str,O_RDWR|O_CREAT|O_BINARY,SH_DENYRW,S_IREAD|S_IWRITE))==-1) { ! 239: return(FALSE); ! 240: } ! 241: length=filelength(file); ! 242: if(length) { /* IXB file isn't empty */ ! 243: if(length%F_IXBSIZE) { ! 244: close(file); ! 245: return(FALSE); ! 246: } ! 247: if((ixbbuf=(uchar *)malloc(length))==NULL) { ! 248: close(file); ! 249: return(FALSE); ! 250: } ! 251: if(lread(file,ixbbuf,length)!=length) { ! 252: close(file); ! 253: free((char *)ixbbuf); ! 254: return(FALSE); ! 255: } ! 256: /************************************************/ ! 257: /* Sort by Name or Date, Assending or Decending */ ! 258: /************************************************/ ! 259: if(cfg->dir[f->dir]->sort==SORT_NAME_A || cfg->dir[f->dir]->sort==SORT_NAME_D) { ! 260: for(l=0;l<length;l+=F_IXBSIZE) { ! 261: for(i=0;i<12 && toupper(fname[i])==toupper(ixbbuf[l+i]);i++); ! 262: if(i==12) { /* file already in directory index */ ! 263: close(file); ! 264: free((char *)ixbbuf); ! 265: return(FALSE); ! 266: } ! 267: if(cfg->dir[f->dir]->sort==SORT_NAME_A ! 268: && toupper(fname[i])<toupper(ixbbuf[l+i])) ! 269: break; ! 270: if(cfg->dir[f->dir]->sort==SORT_NAME_D ! 271: && toupper(fname[i])>toupper(ixbbuf[l+i])) ! 272: break; ! 273: } ! 274: } ! 275: else { /* sort by date */ ! 276: for(l=0;l<length;l+=F_IXBSIZE) { ! 277: uldate=(ixbbuf[l+14]|((long)ixbbuf[l+15]<<8) ! 278: |((long)ixbbuf[l+16]<<16)|((long)ixbbuf[l+17]<<24)); ! 279: if(cfg->dir[f->dir]->sort==SORT_DATE_A && f->dateuled<uldate) ! 280: break; ! 281: if(cfg->dir[f->dir]->sort==SORT_DATE_D && f->dateuled>uldate) ! 282: break; ! 283: } ! 284: } ! 285: lseek(file,l,SEEK_SET); ! 286: if(write(file,fname,11)!=11) { /* Write filename to IXB file */ ! 287: close(file); ! 288: free((char *)ixbbuf); ! 289: return(FALSE); ! 290: } ! 291: if(write(file,idx,3)!=3) { /* Write DAT offset into IXB file */ ! 292: close(file); ! 293: free((char *)ixbbuf); ! 294: return(FALSE); ! 295: } ! 296: write(file,&f->dateuled,sizeof(time_t)); ! 297: write(file,&f->datedled,4); /* Write 0 for datedled */ ! 298: if(lwrite(file,&ixbbuf[l],length-l)!=length-l) { /* Write rest of IXB */ ! 299: close(file); ! 300: free((char *)ixbbuf); ! 301: return(FALSE); ! 302: } ! 303: free((char *)ixbbuf); } ! 304: else { /* IXB file is empty... No files */ ! 305: if(write(file,fname,11)!=11) { /* Write filename it IXB file */ ! 306: close(file); ! 307: return(FALSE); ! 308: } ! 309: if(write(file,idx,3)!=3) { /* Write DAT offset into IXB file */ ! 310: close(file); ! 311: return(FALSE); ! 312: } ! 313: write(file,&f->dateuled,sizeof(time_t)); ! 314: write(file,&f->datedled,4); ! 315: } ! 316: length=filelength(file); ! 317: close(file); ! 318: return(TRUE); ! 319: } ! 320: ! 321: /****************************************************************************/ ! 322: /* Gets file data from dircode.ixb file */ ! 323: /* Need fields .name and .dir filled. */ ! 324: /* only fills .offset, .dateuled, and .datedled */ ! 325: /****************************************************************************/ ! 326: BOOL DLLCALL getfileixb(scfg_t* cfg, file_t* f) ! 327: { ! 328: char str[MAX_PATH+1],fname[13]; ! 329: uchar * ixbbuf; ! 330: int file; ! 331: long l,length; ! 332: ! 333: SAFEPRINTF2(str,"%s%s.ixb",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 334: if((file=sopen(str,O_RDONLY|O_BINARY,SH_DENYWR))==-1) { ! 335: return(FALSE); ! 336: } ! 337: length=filelength(file); ! 338: if(length%F_IXBSIZE) { ! 339: close(file); ! 340: return(FALSE); ! 341: } ! 342: if((ixbbuf=(uchar *)malloc(length))==NULL) { ! 343: close(file); ! 344: return(FALSE); ! 345: } ! 346: if(lread(file,ixbbuf,length)!=length) { ! 347: close(file); ! 348: free((char *)ixbbuf); ! 349: return(FALSE); ! 350: } ! 351: close(file); ! 352: SAFECOPY(fname,f->name); ! 353: for(l=8;l<12;l++) /* Turn FILENAME.EXT into FILENAMEEXT */ ! 354: fname[l]=fname[l+1]; ! 355: for(l=0;l<length;l+=F_IXBSIZE) { ! 356: SAFEPRINTF(str,"%11.11s",ixbbuf+l); ! 357: if(!stricmp(str,fname)) ! 358: break; ! 359: } ! 360: if(l>=length) { ! 361: free((char *)ixbbuf); ! 362: return(FALSE); ! 363: } ! 364: l+=11; ! 365: f->datoffset=ixbbuf[l]|((long)ixbbuf[l+1]<<8)|((long)ixbbuf[l+2]<<16); ! 366: f->dateuled=ixbbuf[l+3]|((long)ixbbuf[l+4]<<8) ! 367: |((long)ixbbuf[l+5]<<16)|((long)ixbbuf[l+6]<<24); ! 368: f->datedled=ixbbuf[l+7]|((long)ixbbuf[l+8]<<8) ! 369: |((long)ixbbuf[l+9]<<16)|((long)ixbbuf[l+10]<<24); ! 370: free((char *)ixbbuf); ! 371: return(TRUE); ! 372: } ! 373: ! 374: /****************************************************************************/ ! 375: /* Updates the datedled and dateuled index record fields for a file */ ! 376: /****************************************************************************/ ! 377: BOOL DLLCALL putfileixb(scfg_t* cfg, file_t* f) ! 378: { ! 379: char str[MAX_PATH+1],fname[13]; ! 380: uchar* ixbbuf; ! 381: int file; ! 382: long l,length; ! 383: ! 384: SAFEPRINTF2(str,"%s%s.ixb",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 385: if((file=sopen(str,O_RDWR|O_BINARY,SH_DENYRW))==-1) { ! 386: return(FALSE); ! 387: } ! 388: length=filelength(file); ! 389: if(length%F_IXBSIZE) { ! 390: close(file); ! 391: return(FALSE); ! 392: } ! 393: if((ixbbuf=(uchar *)malloc(length))==NULL) { ! 394: close(file); ! 395: return(FALSE); ! 396: } ! 397: if(lread(file,ixbbuf,length)!=length) { ! 398: close(file); ! 399: free(ixbbuf); ! 400: return(FALSE); ! 401: } ! 402: SAFECOPY(fname,f->name); ! 403: for(l=8;l<12;l++) /* Turn FILENAME.EXT into FILENAMEEXT */ ! 404: fname[l]=fname[l+1]; ! 405: for(l=0;l<length;l+=F_IXBSIZE) { ! 406: SAFEPRINTF(str,"%11.11s",ixbbuf+l); ! 407: if(!stricmp(str,fname)) ! 408: break; ! 409: } ! 410: free(ixbbuf); ! 411: ! 412: if(l>=length) { ! 413: close(file); ! 414: return(FALSE); ! 415: } ! 416: ! 417: lseek(file,l+11+3,SEEK_SET); ! 418: ! 419: write(file,&f->dateuled,sizeof(f->dateuled)); ! 420: write(file,&f->datedled,sizeof(f->datedled)); ! 421: ! 422: close(file); ! 423: ! 424: return(TRUE); ! 425: } ! 426: ! 427: ! 428: /****************************************************************************/ ! 429: /* Removes DAT and IXB entries for the file in the struct 'f' */ ! 430: /****************************************************************************/ ! 431: BOOL DLLCALL removefiledat(scfg_t* cfg, file_t* f) ! 432: { ! 433: char c,str[MAX_PATH+1],ixbname[12],*ixbbuf,fname[13]; ! 434: int i,file; ! 435: long l,length; ! 436: ! 437: SAFECOPY(fname,f->name); ! 438: for(i=8;i<12;i++) /* Turn FILENAME.EXT into FILENAMEEXT */ ! 439: fname[i]=fname[i+1]; ! 440: SAFEPRINTF2(str,"%s%s.ixb",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 441: if((file=sopen(str,O_RDONLY|O_BINARY,SH_DENYWR))==-1) { ! 442: return(FALSE); ! 443: } ! 444: length=filelength(file); ! 445: if(!length) { ! 446: close(file); ! 447: return(FALSE); ! 448: } ! 449: if((ixbbuf=(char *)malloc(length))==0) { ! 450: close(file); ! 451: return(FALSE); ! 452: } ! 453: if(lread(file,ixbbuf,length)!=length) { ! 454: close(file); ! 455: free((char *)ixbbuf); ! 456: return(FALSE); ! 457: } ! 458: close(file); ! 459: if((file=sopen(str,O_WRONLY|O_TRUNC|O_BINARY,SH_DENYRW))==-1) { ! 460: return(FALSE); ! 461: } ! 462: for(l=0;l<length;l+=F_IXBSIZE) { ! 463: for(i=0;i<11;i++) ! 464: ixbname[i]=ixbbuf[l+i]; ! 465: ixbname[i]=0; ! 466: if(stricmp(ixbname,fname)) ! 467: if(lwrite(file,&ixbbuf[l],F_IXBSIZE)!=F_IXBSIZE) { ! 468: close(file); ! 469: free((char *)ixbbuf); ! 470: return(FALSE); ! 471: } ! 472: } ! 473: free((char *)ixbbuf); ! 474: close(file); ! 475: SAFEPRINTF2(str,"%s%s.dat",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 476: if((file=sopen(str,O_WRONLY|O_BINARY,SH_DENYRW))==-1) { ! 477: return(FALSE); ! 478: } ! 479: lseek(file,f->datoffset,SEEK_SET); ! 480: c=ETX; /* If first char of record is ETX, record is unused */ ! 481: if(write(file,&c,1)!=1) { /* So write a D_T on the first byte of the record */ ! 482: close(file); ! 483: return(FALSE); ! 484: } ! 485: close(file); ! 486: if(f->dir==cfg->user_dir) /* remove file from index */ ! 487: rmuserxfers(cfg,0,0,f->name); ! 488: return(TRUE); ! 489: } ! 490: ! 491: /****************************************************************************/ ! 492: /* Checks directory data file for 'filename' (must be padded). If found, */ ! 493: /* it returns the 1, else returns 0. */ ! 494: /* Called from upload and bulkupload */ ! 495: /****************************************************************************/ ! 496: BOOL DLLCALL findfile(scfg_t* cfg, uint dirnum, char *filename) ! 497: { ! 498: char str[MAX_PATH+1],fname[13],*ixbbuf; ! 499: int i,file; ! 500: long length,l; ! 501: ! 502: SAFECOPY(fname,filename); ! 503: strupr(fname); ! 504: for(i=8;i<12;i++) /* Turn FILENAME.EXT into FILENAMEEXT */ ! 505: fname[i]=fname[i+1]; ! 506: SAFEPRINTF2(str,"%s%s.ixb",cfg->dir[dirnum]->data_dir,cfg->dir[dirnum]->code); ! 507: if((file=sopen(str,O_RDONLY|O_BINARY,SH_DENYWR))==-1) return(FALSE); ! 508: length=filelength(file); ! 509: if(!length) { ! 510: close(file); ! 511: return(FALSE); } ! 512: if((ixbbuf=(char *)malloc(length))==NULL) { ! 513: close(file); ! 514: return(FALSE); } ! 515: if(lread(file,ixbbuf,length)!=length) { ! 516: close(file); ! 517: free((char *)ixbbuf); ! 518: return(FALSE); } ! 519: close(file); ! 520: for(l=0;l<length;l+=F_IXBSIZE) { ! 521: for(i=0;i<11;i++) ! 522: if(toupper(fname[i])!=toupper(ixbbuf[l+i])) break; ! 523: if(i==11) break; } ! 524: free((char *)ixbbuf); ! 525: if(l!=length) ! 526: return(TRUE); ! 527: return(FALSE); ! 528: } ! 529: ! 530: /****************************************************************************/ ! 531: /* Turns FILE.EXT into FILE .EXT */ ! 532: /****************************************************************************/ ! 533: char* DLLCALL padfname(char *filename, char *str) ! 534: { ! 535: int c,d; ! 536: ! 537: for(c=0;c<8;c++) ! 538: if(filename[c]=='.' || !filename[c]) break; ! 539: else str[c]=filename[c]; ! 540: d=c; ! 541: if(filename[c]=='.') c++; ! 542: while(d<8) ! 543: str[d++]=' '; ! 544: if(filename[c]>' ') /* Change "FILE" to "FILE " */ ! 545: str[d++]='.'; /* (don't add a dot if there's no extension) */ ! 546: else ! 547: str[d++]=' '; ! 548: while(d<12) ! 549: if(!filename[c]) break; ! 550: else str[d++]=filename[c++]; ! 551: while(d<12) ! 552: str[d++]=' '; ! 553: str[d]=0; ! 554: return(str); ! 555: } ! 556: ! 557: /****************************************************************************/ ! 558: /* Turns FILE .EXT into FILE.EXT */ ! 559: /****************************************************************************/ ! 560: char* DLLCALL unpadfname(char *filename, char *str) ! 561: { ! 562: int c,d; ! 563: ! 564: for(c=0,d=0;filename[c];c++) ! 565: if(filename[c]!=' ') str[d++]=filename[c]; ! 566: str[d]=0; ! 567: return(str); ! 568: } ! 569: ! 570: /****************************************************************************/ ! 571: /* Removes any files in the user transfer index (XFER.IXT) that match the */ ! 572: /* specifications of dest, or source user, or filename or any combination. */ ! 573: /****************************************************************************/ ! 574: BOOL DLLCALL rmuserxfers(scfg_t* cfg, int fromuser, int destuser, char *fname) ! 575: { ! 576: char str[MAX_PATH+1],*ixtbuf; ! 577: int file; ! 578: long l,length; ! 579: ! 580: SAFEPRINTF(str,"%sxfer.ixt", cfg->data_dir); ! 581: if(!fexist(str)) ! 582: return(FALSE); ! 583: if(!flength(str)) { ! 584: remove(str); ! 585: return(FALSE); ! 586: } ! 587: if((file=sopen(str,O_RDONLY|O_BINARY,SH_DENYWR))==-1) { ! 588: return(FALSE); ! 589: } ! 590: length=filelength(file); ! 591: if((ixtbuf=(char *)malloc(length))==NULL) { ! 592: close(file); ! 593: return(FALSE); ! 594: } ! 595: if(read(file,ixtbuf,length)!=length) { ! 596: close(file); ! 597: free(ixtbuf); ! 598: return(FALSE); ! 599: } ! 600: close(file); ! 601: if((file=sopen(str,O_WRONLY|O_TRUNC|O_BINARY,SH_DENYRW))==-1) { ! 602: free(ixtbuf); ! 603: return(FALSE); ! 604: } ! 605: for(l=0;l<length;l+=24) { ! 606: if(fname!=NULL && fname[0]) { /* fname specified */ ! 607: if(!strncmp(ixtbuf+l+5,fname,12)) { /* this is the file */ ! 608: if(destuser && fromuser) { /* both dest and from user */ ! 609: if(atoi(ixtbuf+l)==destuser && atoi(ixtbuf+l+18)==fromuser) ! 610: continue; } /* both match */ ! 611: else if(fromuser) { /* from user */ ! 612: if(atoi(ixtbuf+l+18)==fromuser) /* matches */ ! 613: continue; } ! 614: else if(destuser) { /* dest user */ ! 615: if(atoi(ixtbuf+l)==destuser) /* matches */ ! 616: continue; } ! 617: else continue; } } /* no users, so match */ ! 618: else if(destuser && fromuser) { ! 619: if(atoi(ixtbuf+l+18)==fromuser && atoi(ixtbuf+l)==destuser) ! 620: continue; } ! 621: else if(destuser && atoi(ixtbuf+l)==destuser) ! 622: continue; ! 623: else if(fromuser && atoi(ixtbuf+l+18)==fromuser) ! 624: continue; ! 625: write(file,ixtbuf+l,24); } ! 626: close(file); ! 627: free(ixtbuf); ! 628: ! 629: return(TRUE); ! 630: } ! 631: ! 632: void DLLCALL getextdesc(scfg_t* cfg, uint dirnum, ulong datoffset, char *ext) ! 633: { ! 634: char str[MAX_PATH+1]; ! 635: int file; ! 636: ! 637: memset(ext,0,F_EXBSIZE+1); ! 638: SAFEPRINTF2(str,"%s%s.exb",cfg->dir[dirnum]->data_dir,cfg->dir[dirnum]->code); ! 639: if((file=nopen(str,O_RDONLY))==-1) ! 640: return; ! 641: lseek(file,(datoffset/F_LEN)*F_EXBSIZE,SEEK_SET); ! 642: read(file,ext,F_EXBSIZE); ! 643: close(file); ! 644: } ! 645: ! 646: void DLLCALL putextdesc(scfg_t* cfg, uint dirnum, ulong datoffset, char *ext) ! 647: { ! 648: char str[MAX_PATH+1],nulbuf[F_EXBSIZE]; ! 649: int file; ! 650: ! 651: strip_invalid_attr(ext); /* eliminate bogus ctrl-a codes */ ! 652: memset(nulbuf,0,sizeof(nulbuf)); ! 653: SAFEPRINTF2(str,"%s%s.exb",cfg->dir[dirnum]->data_dir,cfg->dir[dirnum]->code); ! 654: if((file=nopen(str,O_WRONLY|O_CREAT))==-1) ! 655: return; ! 656: lseek(file,0L,SEEK_END); ! 657: while(filelength(file)<(long)(datoffset/F_LEN)*F_EXBSIZE) ! 658: write(file,nulbuf,sizeof(nulbuf)); ! 659: lseek(file,(datoffset/F_LEN)*F_EXBSIZE,SEEK_SET); ! 660: write(file,ext,F_EXBSIZE); ! 661: close(file); ! 662: } ! 663: ! 664: /****************************************************************************/ ! 665: /* Update the upload date for the file 'f' */ ! 666: /****************************************************************************/ ! 667: int DLLCALL update_uldate(scfg_t* cfg, file_t* f) ! 668: { ! 669: char str[MAX_PATH+1],fname[13]; ! 670: int i,file; ! 671: long l,length; ! 672: ! 673: /*******************/ ! 674: /* Update IXB File */ ! 675: /*******************/ ! 676: SAFEPRINTF2(str,"%s%s.ixb",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 677: if((file=nopen(str,O_RDWR))==-1) ! 678: return(errno); ! 679: length=filelength(file); ! 680: if(length%F_IXBSIZE) { ! 681: close(file); ! 682: return(-1); ! 683: } ! 684: SAFECOPY(fname,f->name); ! 685: for(i=8;i<12;i++) /* Turn FILENAME.EXT into FILENAMEEXT */ ! 686: fname[i]=fname[i+1]; ! 687: for(l=0;l<length;l+=F_IXBSIZE) { ! 688: read(file,str,F_IXBSIZE); /* Look for the filename in the IXB file */ ! 689: str[11]=0; ! 690: if(!strcmp(fname,str)) break; } ! 691: if(l>=length) { ! 692: close(file); ! 693: return(-2); ! 694: } ! 695: lseek(file,l+14,SEEK_SET); ! 696: write(file,&f->dateuled,4); ! 697: close(file); ! 698: ! 699: /*******************************************/ ! 700: /* Update last upload date/time stamp file */ ! 701: /*******************************************/ ! 702: SAFEPRINTF2(str,"%s%s.dab",cfg->dir[f->dir]->data_dir,cfg->dir[f->dir]->code); ! 703: if((file=nopen(str,O_WRONLY|O_CREAT))==-1) ! 704: return(errno); ! 705: ! 706: write(file,&f->dateuled,4); ! 707: close(file); ! 708: return(0); ! 709: } ! 710: ! 711: /****************************************************************************/ ! 712: /* Returns full path to specified file */ ! 713: /****************************************************************************/ ! 714: char* DLLCALL getfilepath(scfg_t* cfg, file_t* f, char* path) ! 715: { ! 716: char fname[MAX_PATH+1]; ! 717: ! 718: unpadfname(f->name,fname); ! 719: if(f->dir>=cfg->total_dirs) ! 720: safe_snprintf(path,MAX_PATH,"%s%s",cfg->temp_dir,fname); ! 721: else ! 722: safe_snprintf(path,MAX_PATH,"%s%s",f->altpath>0 && f->altpath<=cfg->altpaths ! 723: ? cfg->altpath[f->altpath-1] : cfg->dir[f->dir]->path ! 724: ,fname); ! 725: ! 726: return(path); ! 727: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.