home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1998 September / PCO_0998.ISO / filesbbs / dos / sbbs_src.exe / SBBS / DATA_OVL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-13  |  13.9 KB  |  440 lines
  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.  
  440.