![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to smballoc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / smblib|
Return to smballoc.c CVS log | Up to [Synchronet] / sbbs / smblib |
1.1 ! root 1: /* smballoc.c */ ! 2: ! 3: /* Synchronet message base (SMB) alloc/free routines */ ! 4: ! 5: /* $Id: smballoc.c,v 1.4 2004/12/15 04:45:15 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 "smblib.h" ! 39: #include "genwrap.h" ! 40: ! 41: /****************************************************************************/ ! 42: /* Finds unused space in data file based on block allocation table and */ ! 43: /* marks space as used in allocation table. */ ! 44: /* File must be opened read/write DENY ALL */ ! 45: /* Returns offset to beginning of data (in bytes, not blocks) */ ! 46: /* Assumes smb_open_da() has been called */ ! 47: /* smb_close_da() should be called after */ ! 48: /* Returns negative on error */ ! 49: /****************************************************************************/ ! 50: long SMBCALL smb_allocdat(smb_t* smb, ulong length, ushort refs) ! 51: { ! 52: ushort i; ! 53: ulong j,l,blocks,offset=0L; ! 54: ! 55: if(smb->sda_fp==NULL) { ! 56: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open"); ! 57: return(SMB_ERR_NOT_OPEN); ! 58: } ! 59: blocks=smb_datblocks(length); ! 60: j=0; /* j is consecutive unused block counter */ ! 61: fflush(smb->sda_fp); ! 62: rewind(smb->sda_fp); ! 63: while(!feof(smb->sda_fp) && (long)offset>=0) { ! 64: if(smb_fread(smb,&i,sizeof(i),smb->sda_fp)!=sizeof(i)) ! 65: break; ! 66: offset+=SDT_BLOCK_LEN; ! 67: if(!i) j++; ! 68: else j=0; ! 69: if(j==blocks) { ! 70: offset-=(blocks*SDT_BLOCK_LEN); ! 71: break; ! 72: } ! 73: } ! 74: if((long)offset<0) { ! 75: safe_snprintf(smb->last_error,sizeof(smb->last_error),"invalid data offset: %lu",offset); ! 76: return(SMB_ERR_DAT_OFFSET); ! 77: } ! 78: clearerr(smb->sda_fp); ! 79: if(fseek(smb->sda_fp,(offset/SDT_BLOCK_LEN)*sizeof(refs),SEEK_SET)) { ! 80: return(SMB_ERR_SEEK); ! 81: } ! 82: for(l=0;l<blocks;l++) ! 83: if(!fwrite(&refs,sizeof(refs),1,smb->sda_fp)) { ! 84: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 85: ,"%d '%s' writing allocation bytes at offset %ld" ! 86: ,get_errno(),STRERROR(get_errno()) ! 87: ,((offset/SDT_BLOCK_LEN)+l)*sizeof(refs)); ! 88: return(SMB_ERR_WRITE); ! 89: } ! 90: fflush(smb->sda_fp); ! 91: return(offset); ! 92: } ! 93: ! 94: /****************************************************************************/ ! 95: /* Allocates space for data, but doesn't search for unused blocks */ ! 96: /* Returns negative on error */ ! 97: /****************************************************************************/ ! 98: long SMBCALL smb_fallocdat(smb_t* smb, ulong length, ushort refs) ! 99: { ! 100: ulong l,blocks,offset; ! 101: ! 102: if(smb->sda_fp==NULL) { ! 103: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open"); ! 104: return(SMB_ERR_NOT_OPEN); ! 105: } ! 106: fflush(smb->sda_fp); ! 107: clearerr(smb->sda_fp); ! 108: blocks=smb_datblocks(length); ! 109: if(fseek(smb->sda_fp,0L,SEEK_END)) { ! 110: return(SMB_ERR_SEEK); ! 111: } ! 112: offset=(ftell(smb->sda_fp)/sizeof(refs))*SDT_BLOCK_LEN; ! 113: if((long)offset<0) { ! 114: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 115: ,"invalid data offset: %lu",offset); ! 116: return(SMB_ERR_DAT_OFFSET); ! 117: } ! 118: for(l=0;l<blocks;l++) ! 119: if(!fwrite(&refs,sizeof(refs),1,smb->sda_fp)) ! 120: break; ! 121: fflush(smb->sda_fp); ! 122: if(l<blocks) { ! 123: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 124: ,"%d '%s' writing allocation bytes" ! 125: ,get_errno(),STRERROR(get_errno())); ! 126: return(SMB_ERR_WRITE); ! 127: } ! 128: return(offset); ! 129: } ! 130: ! 131: /****************************************************************************/ ! 132: /* De-allocates space for data */ ! 133: /* Returns non-zero on error */ ! 134: /****************************************************************************/ ! 135: int SMBCALL smb_freemsgdat(smb_t* smb, ulong offset, ulong length, ushort refs) ! 136: { ! 137: BOOL da_opened=FALSE; ! 138: int retval=0; ! 139: ushort i; ! 140: ulong l,blocks; ! 141: ulong sda_offset; ! 142: ! 143: if(smb->status.attr&SMB_HYPERALLOC) /* do nothing */ ! 144: return(SMB_SUCCESS); ! 145: ! 146: blocks=smb_datblocks(length); ! 147: ! 148: if(smb->sda_fp==NULL) { ! 149: if((i=smb_open_da(smb))!=SMB_SUCCESS) ! 150: return(i); ! 151: da_opened=TRUE; ! 152: } ! 153: ! 154: clearerr(smb->sda_fp); ! 155: for(l=0;l<blocks;l++) { ! 156: sda_offset=((offset/SDT_BLOCK_LEN)+l)*sizeof(i); ! 157: if(fseek(smb->sda_fp,sda_offset,SEEK_SET)) { ! 158: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 159: ,"%d '%s' seeking to %lu (0x%lX) of allocation file" ! 160: ,get_errno(),STRERROR(get_errno()) ! 161: ,sda_offset,sda_offset); ! 162: retval=SMB_ERR_SEEK; ! 163: break; ! 164: } ! 165: if(smb_fread(smb,&i,sizeof(i),smb->sda_fp)!=sizeof(i)) { ! 166: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 167: ,"%d '%s' reading allocation bytes at offset %ld" ! 168: ,get_errno(),STRERROR(get_errno()) ! 169: ,sda_offset); ! 170: retval=SMB_ERR_READ; ! 171: break; ! 172: } ! 173: if(refs==SMB_ALL_REFS || refs>i) ! 174: i=0; /* don't want to go negative */ ! 175: else ! 176: i-=refs; ! 177: if(fseek(smb->sda_fp,-(int)sizeof(i),SEEK_CUR)) { ! 178: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 179: ,"%d '%s' seeking backwards 2 bytes in allocation file" ! 180: ,get_errno(),STRERROR(get_errno())); ! 181: retval=SMB_ERR_SEEK; ! 182: break; ! 183: } ! 184: if(!fwrite(&i,sizeof(i),1,smb->sda_fp)) { ! 185: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 186: ,"%d '%s' writing allocation bytes at offset %ld" ! 187: ,get_errno(),STRERROR(get_errno()) ! 188: ,sda_offset); ! 189: retval=SMB_ERR_WRITE; ! 190: break; ! 191: } ! 192: } ! 193: fflush(smb->sda_fp); ! 194: if(da_opened) ! 195: smb_close_da(smb); ! 196: return(retval); ! 197: } ! 198: ! 199: /****************************************************************************/ ! 200: /* Adds to data allocation records for blocks starting at 'offset' */ ! 201: /* Returns non-zero on error */ ! 202: /****************************************************************************/ ! 203: int SMBCALL smb_incdat(smb_t* smb, ulong offset, ulong length, ushort refs) ! 204: { ! 205: ushort i; ! 206: ulong l,blocks; ! 207: ! 208: if(smb->sda_fp==NULL) { ! 209: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open"); ! 210: return(SMB_ERR_NOT_OPEN); ! 211: } ! 212: clearerr(smb->sda_fp); ! 213: blocks=smb_datblocks(length); ! 214: for(l=0;l<blocks;l++) { ! 215: if(fseek(smb->sda_fp,((offset/SDT_BLOCK_LEN)+l)*sizeof(i),SEEK_SET)) { ! 216: return(SMB_ERR_SEEK); ! 217: } ! 218: if(smb_fread(smb,&i,sizeof(i),smb->sda_fp)!=sizeof(i)) { ! 219: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 220: ,"%d '%s' reading allocation record at offset %ld" ! 221: ,get_errno(),STRERROR(get_errno()) ! 222: ,((offset/SDT_BLOCK_LEN)+l)*sizeof(i)); ! 223: return(SMB_ERR_READ); ! 224: } ! 225: i+=refs; ! 226: if(fseek(smb->sda_fp,-(int)sizeof(i),SEEK_CUR)) { ! 227: return(SMB_ERR_SEEK); ! 228: } ! 229: if(!fwrite(&i,sizeof(i),1,smb->sda_fp)) { ! 230: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 231: ,"%d '%s' writing allocation record at offset %ld" ! 232: ,get_errno(),STRERROR(get_errno()) ! 233: ,((offset/SDT_BLOCK_LEN)+l)*sizeof(i)); ! 234: return(SMB_ERR_WRITE); ! 235: } ! 236: } ! 237: fflush(smb->sda_fp); ! 238: return(SMB_SUCCESS); ! 239: } ! 240: ! 241: /****************************************************************************/ ! 242: /* Increments data allocation records (message references) by number of */ ! 243: /* header references specified (usually 1) */ ! 244: /* The opposite function of smb_freemsg() */ ! 245: /****************************************************************************/ ! 246: int SMBCALL smb_incmsg_dfields(smb_t* smb, smbmsg_t* msg, ushort refs) ! 247: { ! 248: int i=0; ! 249: BOOL da_opened=FALSE; ! 250: ushort x; ! 251: ! 252: if(smb->status.attr&SMB_HYPERALLOC) /* Nothing to do */ ! 253: return(SMB_SUCCESS); ! 254: ! 255: if(smb->sda_fp==NULL) { ! 256: if((i=smb_open_da(smb))!=SMB_SUCCESS) ! 257: return(i); ! 258: da_opened=TRUE; ! 259: } ! 260: ! 261: for(x=0;x<msg->hdr.total_dfields;x++) { ! 262: if((i=smb_incdat(smb,msg->hdr.offset+msg->dfield[x].offset ! 263: ,msg->dfield[x].length,refs))!=SMB_SUCCESS) ! 264: break; ! 265: } ! 266: ! 267: if(da_opened) ! 268: smb_close_da(smb); ! 269: return(i); ! 270: } ! 271: ! 272: /****************************************************************************/ ! 273: /* De-allocates blocks for header record */ ! 274: /* Returns non-zero on error */ ! 275: /****************************************************************************/ ! 276: int SMBCALL smb_freemsghdr(smb_t* smb, ulong offset, ulong length) ! 277: { ! 278: uchar c=0; ! 279: ulong l,blocks; ! 280: ! 281: if(smb->sha_fp==NULL) { ! 282: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open"); ! 283: return(SMB_ERR_NOT_OPEN); ! 284: } ! 285: clearerr(smb->sha_fp); ! 286: blocks=smb_hdrblocks(length); ! 287: if(fseek(smb->sha_fp,offset/SHD_BLOCK_LEN,SEEK_SET)) ! 288: return(SMB_ERR_SEEK); ! 289: for(l=0;l<blocks;l++) ! 290: if(!fwrite(&c,1,1,smb->sha_fp)) { ! 291: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 292: ,"%d '%s' writing allocation record" ! 293: ,get_errno(),STRERROR(get_errno())); ! 294: return(SMB_ERR_WRITE); ! 295: } ! 296: fflush(smb->sha_fp); ! 297: return(SMB_SUCCESS); ! 298: } ! 299: ! 300: /****************************************************************************/ ! 301: /****************************************************************************/ ! 302: int SMBCALL smb_freemsg_dfields(smb_t* smb, smbmsg_t* msg, ushort refs) ! 303: { ! 304: int i; ! 305: ushort x; ! 306: ! 307: for(x=0;x<msg->hdr.total_dfields;x++) { ! 308: if((i=smb_freemsgdat(smb,msg->hdr.offset+msg->dfield[x].offset ! 309: ,msg->dfield[x].length,refs))!=SMB_SUCCESS) ! 310: return(i); ! 311: } ! 312: return(SMB_SUCCESS); ! 313: } ! 314: ! 315: /****************************************************************************/ ! 316: /* Frees all allocated header and data blocks (1 reference) for 'msg' */ ! 317: /****************************************************************************/ ! 318: int SMBCALL smb_freemsg(smb_t* smb, smbmsg_t* msg) ! 319: { ! 320: int i; ! 321: ! 322: if(smb->status.attr&SMB_HYPERALLOC) /* Nothing to do */ ! 323: return(SMB_SUCCESS); ! 324: ! 325: if(!smb_valid_hdr_offset(smb,msg->idx.offset)) ! 326: return(SMB_ERR_HDR_OFFSET); ! 327: ! 328: if((i=smb_freemsg_dfields(smb,msg,1))!=SMB_SUCCESS) ! 329: return(i); ! 330: ! 331: return(smb_freemsghdr(smb,msg->idx.offset-smb->status.header_offset ! 332: ,msg->hdr.length)); ! 333: } ! 334: ! 335: /****************************************************************************/ ! 336: /* Finds unused space in header file based on block allocation table and */ ! 337: /* marks space as used in allocation table. */ ! 338: /* File must be opened read/write DENY ALL */ ! 339: /* Returns offset to beginning of header (in bytes, not blocks) */ ! 340: /* Assumes smb_open_ha() has been called */ ! 341: /* smb_close_ha() should be called after */ ! 342: /* Returns negative value on error */ ! 343: /****************************************************************************/ ! 344: long SMBCALL smb_allochdr(smb_t* smb, ulong length) ! 345: { ! 346: uchar c; ! 347: ulong i,l,blocks,offset=0; ! 348: ! 349: if(smb->sha_fp==NULL) { ! 350: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open"); ! 351: return(SMB_ERR_NOT_OPEN); ! 352: } ! 353: blocks=smb_hdrblocks(length); ! 354: i=0; /* i is consecutive unused block counter */ ! 355: fflush(smb->sha_fp); ! 356: rewind(smb->sha_fp); ! 357: while(!feof(smb->sha_fp)) { ! 358: if(smb_fread(smb,&c,sizeof(c),smb->sha_fp)!=sizeof(c)) ! 359: break; ! 360: offset+=SHD_BLOCK_LEN; ! 361: if(!c) i++; ! 362: else i=0; ! 363: if(i==blocks) { ! 364: offset-=(blocks*SHD_BLOCK_LEN); ! 365: break; ! 366: } ! 367: } ! 368: clearerr(smb->sha_fp); ! 369: if(fseek(smb->sha_fp,offset/SHD_BLOCK_LEN,SEEK_SET)) ! 370: return(SMB_ERR_SEEK); ! 371: ! 372: for(l=0;l<blocks;l++) ! 373: if(fputc(1,smb->sha_fp)!=1) { ! 374: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 375: ,"%d '%s' writing allocation record" ! 376: ,get_errno(),STRERROR(get_errno())); ! 377: return(SMB_ERR_WRITE); ! 378: } ! 379: fflush(smb->sha_fp); ! 380: return(offset); ! 381: } ! 382: ! 383: /****************************************************************************/ ! 384: /* Allocates space for index, but doesn't search for unused blocks */ ! 385: /* Returns negative value on error */ ! 386: /****************************************************************************/ ! 387: long SMBCALL smb_fallochdr(smb_t* smb, ulong length) ! 388: { ! 389: uchar c=1; ! 390: ulong l,blocks,offset; ! 391: ! 392: if(smb->sha_fp==NULL) { ! 393: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open"); ! 394: return(SMB_ERR_NOT_OPEN); ! 395: } ! 396: blocks=smb_hdrblocks(length); ! 397: fflush(smb->sha_fp); ! 398: clearerr(smb->sha_fp); ! 399: if(fseek(smb->sha_fp,0L,SEEK_END)) ! 400: return(SMB_ERR_SEEK); ! 401: offset=ftell(smb->sha_fp)*SHD_BLOCK_LEN; ! 402: for(l=0;l<blocks;l++) ! 403: if(!fwrite(&c,1,1,smb->sha_fp)) { ! 404: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 405: ,"%d '%s' writing allocation record" ! 406: ,get_errno(),STRERROR(get_errno())); ! 407: return(SMB_ERR_WRITE); ! 408: } ! 409: fflush(smb->sha_fp); ! 410: return(offset); ! 411: } ! 412: ! 413: /************************************************************************/ ! 414: /* Allocate header blocks using Hyper Allocation */ ! 415: /* this function should be most likely not be called from anywhere but */ ! 416: /* smb_addmsghdr() */ ! 417: /************************************************************************/ ! 418: long SMBCALL smb_hallochdr(smb_t* smb) ! 419: { ! 420: ulong offset; ! 421: ! 422: if(smb->shd_fp==NULL) { ! 423: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open"); ! 424: return(SMB_ERR_NOT_OPEN); ! 425: } ! 426: fflush(smb->shd_fp); ! 427: if(fseek(smb->shd_fp,0L,SEEK_END)) ! 428: return(SMB_ERR_SEEK); ! 429: offset=ftell(smb->shd_fp); ! 430: if(offset<smb->status.header_offset) /* Header file truncated?!? */ ! 431: return(smb->status.header_offset); ! 432: ! 433: offset-=smb->status.header_offset; /* SMB headers not included */ ! 434: ! 435: /* Even block boundry */ ! 436: offset+=PAD_LENGTH_FOR_ALIGNMENT(offset,SHD_BLOCK_LEN); ! 437: ! 438: return(offset); ! 439: } ! 440: ! 441: /************************************************************************/ ! 442: /* Allocate data blocks using Hyper Allocation */ ! 443: /* smb_locksmbhdr() should be called before this function and not */ ! 444: /* unlocked until all data fields for this message have been written */ ! 445: /* to the SDT file */ ! 446: /************************************************************************/ ! 447: long SMBCALL smb_hallocdat(smb_t* smb) ! 448: { ! 449: long offset; ! 450: ! 451: if(smb->sdt_fp==NULL) { ! 452: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 453: ,"msgbase not open"); ! 454: return(SMB_ERR_NOT_OPEN); ! 455: } ! 456: fflush(smb->sdt_fp); ! 457: offset=filelength(fileno(smb->sdt_fp)); ! 458: if(offset<0) { ! 459: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 460: ,"invalid file length: %lu",(ulong)offset); ! 461: return(SMB_ERR_FILE_LEN); ! 462: } ! 463: if(fseek(smb->sdt_fp,0L,SEEK_END)) ! 464: return(SMB_ERR_SEEK); ! 465: offset=ftell(smb->sdt_fp); ! 466: if(offset<0) { ! 467: safe_snprintf(smb->last_error,sizeof(smb->last_error) ! 468: ,"invalid file offset: %ld",offset); ! 469: return(SMB_ERR_DAT_OFFSET); ! 470: } ! 471: ! 472: /* Make sure even block boundry */ ! 473: offset+=PAD_LENGTH_FOR_ALIGNMENT(offset,SDT_BLOCK_LEN); ! 474: ! 475: return(offset); ! 476: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.