home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume42 / mbox / part05 < prev    next >
Encoding:
Internet Message Format  |  1994-03-29  |  90.6 KB

  1. From: Volker.Schuermann@unnet.wupper.de (Volker Schuermann)
  2. Newsgroups: comp.sources.misc
  3. Subject: v42i028:  mbox - ix/MBox BBS, v2.1, Part05/12
  4. Date: 29 Mar 1994 21:07:39 -0600
  5. Organization: THE UNDERGROUND NETWORK
  6. Sender: kent@sparky.sterling.com
  7. Approved: kent@sparky.sterling.com
  8. Message-ID: <2naqdr$iqs@sparky.sterling.com>
  9. Reply-To: Volker Schuermann <Volker.Schuermann@unnet.wupper.de>
  10. X-Md4-Signature: 943f034684289ce45e157c75bd6c0369
  11.  
  12. Submitted-by: Volker.Schuermann@unnet.wupper.de (Volker Schuermann)
  13. Posting-number: Volume 42, Issue 28
  14. Archive-name: mbox/part05
  15. Environment: MINIX, ISC, ESIX, SVR3, LINUX, SVR4
  16. Supersedes: mbox: Volume 35, Issue 36-50
  17.  
  18. #! /bin/sh
  19. # This is a shell archive.  Remove anything before this line, then feed it
  20. # into a shell via "sh file" or similar.  To overwrite existing files,
  21. # type "sh file -c".
  22. # Contents:  mbox/contrib/wendy/ctrl.c mbox/src/intro.c
  23. #   mbox/src/languages/francais.shh mbox/src/pd.c mbox/src/xmd.c
  24. # Wrapped by kent@sparky on Thu Mar 24 21:48:34 1994
  25. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
  26. echo If this archive is complete, you will see the following message:
  27. echo '          "shar: End of archive 5 (of 12)."'
  28. if test -f 'mbox/contrib/wendy/ctrl.c' -a "${1}" != "-c" ; then 
  29.   echo shar: Will not clobber existing file \"'mbox/contrib/wendy/ctrl.c'\"
  30. else
  31.   echo shar: Extracting \"'mbox/contrib/wendy/ctrl.c'\" \(21334 characters\)
  32.   sed "s/^X//" >'mbox/contrib/wendy/ctrl.c' <<'END_OF_FILE'
  33. X/* ix/MBox/WENDY (ctrl.c) by Volker Schuermann, 04.12.1993
  34. X
  35. X   This C source code contains the following functions:
  36. X
  37. X   #CG ctrlg()          display state
  38. X   #CH ctrlh()          process <BS> key
  39. X   #CV ctrlv()          process <INS> key
  40. X   #CJ ctrlj()          process <DOWN> cursor key
  41. X   #CK ctrlk()          process <UP> cursor key
  42. X   #CN ctrln()          insert RTF CONTENT line
  43. X   #CU ctrlu()          choose RTF attribute
  44. X   #CS ctrls()          change setup
  45. X   #CT ctrlt()          delete from cursor position to eoln
  46. X   #CW ctrlw()          save text
  47. X   #CX ctrlx()          quit session
  48. X   #CY ctrly()          delete a line
  49. X
  50. X   Contact <volkers@unnet.wupper.de> for help! */
  51. X
  52. X
  53. X
  54. X
  55. X#include "wendy.h"
  56. X
  57. X/* #CG - Display state of the session */ 
  58. Xctrlg( f )
  59. Xunsigned char f[];
  60. X{
  61. X  unsigned char s[STRING];
  62. X  unsigned char t[STRING];
  63. X  t[0] = '\0';
  64. X
  65. X#ifdef _LOCAL 
  66. X  if(INS_mode != 0)
  67. X    strcpy(t, (unsigned char *) " - Einfuege-Modus");
  68. X  sprintf(s, " %s - Spalte %d, Zeile %d (%d) %s", f, x, (ypos + y - 2), lastline, t);
  69. X#else
  70. X  if(INS_mode != 0)
  71. X    strcpy(t, (unsigned char *) " - Insert-Mode");
  72. X  sprintf(s, " %s - Column %d, Line %d (%d) %s", f, x, (ypos + y -1), lastline, t);
  73. X#endif
  74. X  show_status( s );
  75. X  activate( RTF_attrib );
  76. X  ansi2( "cm", x, y );
  77. X}
  78. X/* #CH - Process <BS> key */
  79. Xctrlh()
  80. X{
  81. X  unsigned char s[LONGSTRING];
  82. X  unsigned char a[LONGSTRING];
  83. X  unsigned char q[LONGSTRING];
  84. X  int i, j;
  85. X  if(x == 1){
  86. X    if(y == START) return;
  87. X    strcpy(s, (unsigned char *) SCREEN[y-1]);
  88. X    i = strlen((unsigned char *) right_stripped(s));
  89. X    strcpy(s, (unsigned char *) SCREEN[y]);
  90. X    j = strlen((unsigned char *) right_stripped(s));
  91. X    SCREEN[(y-1)][i] = '\0';
  92. X    ATTRIB[(y-1)][i] = '\0';
  93. X    strcpy(s, (unsigned char *) SCREEN[(y-1)]); strcat(s, (unsigned char *) SCREEN[y]);
  94. X    strcat(s, (unsigned char *) "                           ");
  95. X    strcpy(a, (unsigned char *) ATTRIB[(y-1)]); strcat(a, (unsigned char *) ATTRIB[y]);
  96. X    strcat(a, (unsigned char *) "0000000000000000000000000000000000000000000000000000000000000000000000000000000");
  97. X    strcpy(SCREEN[y], (unsigned char *) strcopy(s, MAXX, MAXX+MAXX));
  98. X    strcpy(ATTRIB[y], (unsigned char *) strcopy(a, MAXX, MAXX+MAXX));
  99. X    s[MAXX] = '\0'; strcpy(SCREEN[(y-1)], (unsigned char *) s);
  100. X    a[MAXX] = '\0'; strcpy(ATTRIB[(y-1)], (unsigned char *) a);
  101. X
  102. X    strcpy(q, (unsigned char *) right_stripped(SCREEN[y]));
  103. X
  104. X    if(strlen((unsigned char *) right_stripped(q)) < 1)
  105. X        ctrly();
  106. X    else
  107. X        show_line( SCREEN[y], ATTRIB[y], 1 );
  108. X
  109. X    y--; x = i + 1;
  110. X    show_line( SCREEN[y], ATTRIB[y], x );
  111. X    ansi2( "cm", x, y );
  112. X
  113. X    return;
  114. X  }
  115. X  strcpy(s, (unsigned char *) SCREEN[y]);
  116. X  s[(x-2)] = '\0';
  117. X  strcat(s, (unsigned char *) strcopy(SCREEN[y], (x-1), strlen(SCREEN[y])));
  118. X  strcat(s, "            ");
  119. X  s[MAXX] = '\0';
  120. X  strcpy(SCREEN[y], (unsigned char *) s);
  121. X  strcpy(s, (unsigned char *) ATTRIB[y]);
  122. X  s[(x-2)] = '\0';
  123. X  strcat(s, (unsigned char *) strcopy(ATTRIB[y], (x-1), strlen(ATTRIB[y])));
  124. X  strcat(s, "0000000000000000000000000000000000000000000000000000000000000000000000000000000");
  125. X  s[MAXX] = '\0';
  126. X  strcpy(ATTRIB[y], (unsigned char *) s);
  127. X  x--;
  128. X  ansi2( "cm", x, y );
  129. X  if(ansi( "dc" ) != 0){
  130. X        show_line( SCREEN[y], ATTRIB[y], x );
  131. X    ansi2( "cm", x, y );
  132. X  }
  133. X}
  134. X/* #CV - Process <INS> key */
  135. Xctrlv()
  136. X{
  137. X  if(INS_mode == 0){
  138. X        INS_mode = 1;
  139. X#ifdef _LOCAL
  140. X        show_status( " WENDY: Einfuegemodus aktiviert. " );
  141. X#else
  142. X    show_status( " WENDY: Insert mode activated. " );
  143. X#endif
  144. X  }
  145. X  else{
  146. X        INS_mode = 0;
  147. X#ifdef _LOCAL
  148. X        show_status( " WENDY: Einfuegemodus aus. " );
  149. X#else
  150. X    show_status( " WENDY: Insert mode deactivated. " );
  151. X#endif
  152. X  }
  153. X  ansi2( "cm", x, y );
  154. X}
  155. X/* #CJ - Process cursor <DOWN> key */
  156. Xctrlj()
  157. X{
  158. X  int ymem = y;
  159. X
  160. X  if((y < MAXY) && (y < lastline)){
  161. X    ansi( "do" );
  162. X        y++;
  163. X    return;
  164. X  }
  165. X
  166. X  if(ypos < (lastline - MAXY)){
  167. X        restore_screen( ypos );
  168. X        ypos++;
  169. X        prep_screen( ypos );
  170. X
  171. X
  172. X    ansi2( "cm", 1, START );
  173. X
  174. X
  175. X    if(ansi( "dl" ) != 0){
  176. X        show_screen( START );
  177. X    }
  178. X    else{
  179. X        y = MAXY;
  180. X        show_line( SCREEN[MAXY], ATTRIB[MAXY], 1 );
  181. X        y = ymem;
  182. X    }
  183. X    ansi2( "cm", x, y );
  184. X  }
  185. X}
  186. X/* #CK - Process cursor <UP> key */
  187. Xctrlk()
  188. X{
  189. X  if(y > START){
  190. X    ansi( "up" );
  191. X        y--;
  192. X    return;
  193. X  }
  194. X
  195. X  if(ypos > 1){            /* 1(!), nicht START (!) */
  196. X        restore_screen( ypos );
  197. X        ypos--;
  198. X        prep_screen( ypos );
  199. X
  200. X
  201. X    ansi2( "cm", 1, MAXY );
  202. X    ansi( "ce" );
  203. X    ansi2( "cm", x, y );
  204. X
  205. X
  206. X    if(ansi( "al" ) != 0){
  207. X        show_screen( START );
  208. X    }
  209. X    else{
  210. X        show_line( SCREEN[y], ATTRIB[y], 1);
  211. X        ansi2( "cm", x, y );
  212. X    }
  213. X  }
  214. X}
  215. X
  216. X/* #CN - Insert a RTF "Content:" line */
  217. Xctrln()
  218. X{
  219. X  if(RTF_toggle == 0){
  220. X    FLAG[(ypos + y - 1)] &= ~is_plain;
  221. X    FLAG[(ypos + y - 1)] |=  is_richtext;
  222. X#ifdef _LOCAL
  223. X    show_status( "Der folgende Text wird klassifiziert als 'text/richtext'." );
  224. X#else
  225. X    show_status( "The following text is classified as 'text/richtext'." );
  226. X#endif
  227. X        RTF_toggle++;
  228. X  }
  229. X  else{
  230. X    FLAG[(ypos + y - 1)] &= ~is_richtext;
  231. X    FLAG[(ypos + y - 1)] |=  is_plain;
  232. X#ifdef _LOCAL
  233. X    show_status( "Der folgende Text wird klassifiziert als 'text/plain'." );
  234. X#else
  235. X    show_status( "The following text is classified as 'text/plain'." );
  236. X#endif
  237. X        RTF_toggle = 0;
  238. X  }
  239. X  activate( RTF_attrib );
  240. X  ansi2( "cm", x, y );
  241. X}
  242. X
  243. X
  244. Xctrlu_output()
  245. X{
  246. X  ansi( "me"); ansi( "us" );
  247. X
  248. X  if(RTF_attrib == 'b'){
  249. X    ansi2( "cm", 8,  1 ); printf("B");    
  250. X  }
  251. X  if(FORMATTER == 'c'){
  252. X    ansi2( "cm", 16, 1 ); printf("C");    
  253. X  }
  254. X  if(RTF_attrib == 'f'){
  255. X    ansi2( "cm", 26, 1 ); printf("F");    
  256. X  }
  257. X  if(RTF_attrib == 'i'){
  258. X    ansi2( "cm", 35, 1 ); printf("I");    
  259. X  }
  260. X  if(RTF_attrib == '0'){
  261. X    ansi2( "cm", 45, 1 ); printf("N");    
  262. X  }
  263. X  if(FORMATTER == 'b'){
  264. X    ansi2( "cm", 57, 1 ); printf("o");    
  265. X  }
  266. X  if(RTF_attrib == 'u'){
  267. X    ansi2( "cm", 67, 1 ); printf("U");    
  268. X  }  
  269. X
  270. X  ansi( "mr" );
  271. X  if(RTF_attrib != 'b'){
  272. X    ansi2( "cm", 8,  1 ); printf("B");    
  273. X  }
  274. X  if(FORMATTER != 'c'){
  275. X    ansi2( "cm", 16, 1 ); printf("C");    
  276. X  }
  277. X  if(RTF_attrib != 'f'){
  278. X    ansi2( "cm", 26, 1 ); printf("F");    
  279. X  }
  280. X  if(RTF_attrib != 'i'){
  281. X    ansi2( "cm", 35, 1 ); printf("I");    
  282. X  }
  283. X  if(RTF_attrib != '0'){
  284. X    ansi2( "cm", 45, 1 ); printf("N");    
  285. X  }
  286. X  if(FORMATTER != 'b'){
  287. X    ansi2( "cm", 57, 1 ); printf("o");    
  288. X  }
  289. X  if(RTF_attrib != 'u'){
  290. X    ansi2( "cm", 67, 1 ); printf("U");    
  291. X  }  
  292. X
  293. X}
  294. X
  295. X/* #CU - Choose RTF attribute */
  296. X
  297. Xctrlu()
  298. X{
  299. X  int c;
  300. X  show_status( " RTF: <B>old  <C>enter  <F>lash  <I>talic  <N>ormal  Bl<o>ckset  <U>nderline " );
  301. X
  302. X  REALLY++;
  303. X
  304. X  do{
  305. X    ctrlu_output();
  306. X      ansi2( "cm", 45, 1 );
  307. X    c = getch();
  308. X    if(c == ESC){
  309. X        do{
  310. X            c = getch();
  311. X        }while(c < 65);
  312. X        c = getch();
  313. X#ifdef _LOCAL
  314. X        show_status( " WENDY: Noe, Auswahl per Cursortaste ist noch nicht implementiert ;-) ");
  315. X#else
  316. X        show_status( " WENDY: Nope! Selection by cursor keys' not implemented yet!" );
  317. X#endif
  318. X        activate( RTF_attrib );
  319. X        ansi2( "cm", x, y );
  320. X        return;
  321. X     }
  322. X
  323. X    switch(c){
  324. X        case 'b' :
  325. X        case 'B' :     if(RTF_attrib == 'b') 
  326. X                    RTF_attrib = '0';
  327. X                else
  328. X                    RTF_attrib = 'b';
  329. X                break;
  330. X        case 'c' :
  331. X        case 'C' :    if(FORMATTER == 'c')
  332. X                    FORMATTER = 0;
  333. X                else
  334. X                    FORMATTER = 'c';
  335. X                break;
  336. X        case 'f' :
  337. X        case 'F' :    if(RTF_attrib == 'f')
  338. X                    RTF_attrib = '0';
  339. X                else
  340. X                    RTF_attrib = 'f';
  341. X                break;
  342. X        case 'i' :
  343. X        case 'I' :    if(RTF_attrib == 'i')
  344. X                    RTF_attrib = '0';
  345. X                else
  346. X                    RTF_attrib = 'i';
  347. X                break;
  348. X        case 'n' :
  349. X        case 'N' :    FORMATTER = 0;
  350. X                RTF_attrib = '0';
  351. X                break;
  352. X        case 'o' :
  353. X        case 'O' :    if(FORMATTER == 'o')
  354. X                    FORMATTER = 0;
  355. X                else
  356. X                    FORMATTER = 'b';
  357. X                break;
  358. X        case 'u' :
  359. X        case 'U' :    if(RTF_attrib == 'u')
  360. X                    RTF_attrib = '0';
  361. X                else
  362. X                    RTF_attrib = 'u';
  363. X                break;
  364. X        
  365. X    }    
  366. X  }while(isin("bBcCfFiIoOuU") != 0);
  367. X
  368. X  ctrlu_output();
  369. X
  370. X  if(BLOCK.status == BLOCKMODE) block_ctrlu();
  371. X
  372. X  activate( RTF_attrib );
  373. X  ansi2( "cm", x, y );
  374. X}
  375. X
  376. X
  377. X
  378. Xctrls_output()
  379. X{
  380. X  if(MAXX <  10) MAXX =  10;
  381. X  if(MAXX > 136) MAXX = 136;
  382. X  if(MAXY <   4) MAXY =   4;
  383. X  if(MAXY >  24) MAXY =  24;
  384. X
  385. X  ansi( "me" );
  386. X#ifdef _LOCAL
  387. X  ansi2( "cm", 25,  5); printf("%d  ", MAXX);
  388. X  ansi2( "cm", 25,  7); printf("%d  ", MAXY);
  389. X
  390. X  ansi2( "cm", 67,  5); printf("%s           ", terminal);
  391. X  ansi2( "cm", 67,  7); printf("%s           ", umlaut);
  392. X#else
  393. X  ansi2( "cm", 27,  5); printf("%d  ", MAXX);
  394. X  ansi2( "cm", 27,  7); printf("%d  ", MAXY);
  395. X
  396. X  ansi2( "cm", 66,  5); printf("%s           ", terminal);
  397. X  ansi2( "cm", 66,  7); printf("%s           ", umlaut);
  398. X#endif
  399. X}
  400. X
  401. X/* #CS - Change setup */
  402. Xctrls()
  403. X{
  404. X  FILE *fp;
  405. X  unsigned char s[STRING];
  406. X  unsigned char *home;
  407. X  int c, d;
  408. X
  409. X
  410. X  restore_screen( ypos );
  411. X  ansi( "cl" );
  412. X
  413. X#ifdef _LOCAL
  414. X
  415. X  show_status( " WENDY: Parameter aendern ... " );
  416. X  
  417. X  ansi2( "cm",  1,  3 ); printf("Aktive Parameter:");
  418. X
  419. X  ansi( "mr" );
  420. X  ansi2( "cm",  1,  5 ); printf(" 1 ");
  421. X  ansi2( "cm",  5,  5 ); printf(" Zeichen pro Zeile " );
  422. X  ansi2( "cm",  1,  7 ); printf(" 2 ");
  423. X  ansi2( "cm",  5,  7 ); printf(" Anzahl der Zeilen " );
  424. X
  425. X  ansi2( "cm", 40,  5 ); printf(" 3 ");
  426. X  ansi2( "cm", 44,  5 ); printf(" Terminal-Emulation   " );
  427. X  ansi2( "cm", 40,  7 ); printf(" 4 " );
  428. X  ansi2( "cm", 44,  7 ); printf(" Umlaut-Konvertierung " );
  429. X
  430. X  ansi( "me" );
  431. X  ansi2( "cm",  1, 10); printf("Vordefinierte Konfigurationen:");
  432. X  
  433. X  ansi( "mr" );
  434. X  ansi2( "cm",  1, 12); printf(" 5 ");
  435. X  ansi2( "cm",  5, 12); printf(" UNIX (Console)          ");
  436. X  ansi2( "cm",  1, 14); printf(" 6 ");
  437. X  ansi2( "cm",  5, 14); printf(" LINUX (Console)         ");
  438. X  ansi2( "cm",  1, 16); printf(" 7 ");
  439. X  ansi2( "cm",  5, 16); printf(" DOS (ProComm ab 2.4.1)  ");
  440. X  
  441. X  ansi2( "cm", 40, 12); printf(" 8 ");
  442. X  ansi2( "cm", 44, 12); printf(" DOS (TELIX ab 3.11)      ");
  443. X  ansi2( "cm", 40, 14); printf(" 9 ");
  444. X  ansi2( "cm", 44, 14); printf(" DOS (Telemate ab 2.11)   ");
  445. X
  446. X  ctrls_output();
  447. X  do{
  448. X        ansi2( "cm", 1, 19); printf("Nun, was soll's denn sein?      ");
  449. X    ansi2( "cm", 28, 19 );
  450. X    c = getch();
  451. X    ansi2( "cm", 1, 19 );
  452. X    switch(c){
  453. X        case '1' :    ansi( "ce" );
  454. X                printf("Zeichen pro Zeile (10-136): ");
  455. X                sprintf(s, "%d", MAXX);
  456. X                strcpy(s, (unsigned char *) getline( 3, 1101, '.', s));
  457. X                MAXX = atoi(s);
  458. X                break;
  459. X        case '2' :    ansi( "ce" );
  460. X                printf("Bildschirmzeilen (4-24): ");
  461. X                sprintf(s, "%d", MAXY);
  462. X                strcpy(s, (unsigned char *) getline( 2, 1101, '.', s));
  463. X                MAXY = atoi(s);
  464. X                break;
  465. X        case '3' :    ansi( "mr" );
  466. X                ansi2( "cm",  1, 21); printf(" A ");
  467. X                ansi2( "cm",  5, 21); printf(" ANSI (X3.64)  ");
  468. X                ansi2( "cm", 30, 21); printf(" B ");
  469. X                ansi2( "cm", 34, 21); printf(" DEC VT100     "); 
  470. X                ansi2( "cm", 60, 21); printf(" C ");
  471. X                ansi2( "cm", 64, 21); printf(" MINIX CONSOLE ");
  472. X                ansi( "me" );
  473. X
  474. X                ansi2( "cm", 1, 19 ); ansi( "ce" );
  475. X                printf("Terminal-Emulation (A-C): ");
  476. X
  477. X                do{
  478. X                    d = getch();
  479. X                }while(isin("abcABC", d) == 0);
  480. X    
  481. X                switch(d){
  482. X                    case 'a' :
  483. X                    case 'A' :    strcpy(terminal, (unsigned char *) "ansi");
  484. X                            break;
  485. X                    case 'b' :
  486. X                    case 'B' :    strcpy(terminal, (unsigned char *) "vt100");
  487. X                            break;
  488. X                    case 'c' :
  489. X                    case 'C' :    strcpy(terminal, (unsigned char *) "minix");
  490. X                            break;
  491. X                }        
  492. X                ansi2( "cm",  1, 21); ansi( "ce" );    
  493. X                break;
  494. X        case '4' :    ansi( "mr" );
  495. X                ansi2( "cm",  1, 21); printf(" A ");
  496. X                ansi2( "cm",  5, 21); printf(" ISO-8859-1  ");
  497. X                ansi2( "cm", 30, 21); printf(" B ");
  498. X                ansi2( "cm", 34, 21); printf(" IBM-Umlaute "); 
  499. X                ansi( "me" );
  500. X
  501. X                ansi2( "cm", 1, 19 ); ansi( "ce" );
  502. X                printf("Umlaut-Konvertierung (A-B): ");
  503. X
  504. X                do{
  505. X                    d = getch();
  506. X                }while(isin("abAB", d) == 0);
  507. X    
  508. X                switch(d){
  509. X                    case 'a' :
  510. X                    case 'A' :    strcpy(umlaut, (unsigned char *) "iso-8859-1");
  511. X                            break;
  512. X                    case 'b' :
  513. X                    case 'B' :    strcpy(umlaut, (unsigned char *) "ibm");
  514. X                            break;
  515. X                }        
  516. X                ansi2( "cm",  1, 21); ansi( "ce" );    
  517. X                break;
  518. X        case '5' :    MAXX = 80;
  519. X                MAXY = 24;
  520. X                wBS = 127; wDEL = 9151; wINS = 9150; wEND = 9152;
  521. X                strcpy(terminal, (unsigned char *) "vt100");
  522. X                strcpy(umlaut, (unsigned char *) "iso-8859-1");    
  523. X                break;
  524. X        case '6' :    MAXX = 80;
  525. X                MAXY = 24;
  526. X                wBS = 127; wDEL = 9151; wINS = 9150; wEND = 9152; 
  527. X                strcpy(terminal, (unsigned char *) "ansi-color");
  528. X                strcpy(umlaut, (unsigned char *) "iso-8850-1");    
  529. X                break;
  530. X        case '7' :    MAXX = 79;
  531. X                MAXY = 24;
  532. X                wBS = 8; wDEL = 9152; wINS = 9151; wEND = 9189;
  533. X                strcpy(terminal, (unsigned char *) "ansi");
  534. X                strcpy(umlaut, (unsigned char *) "ibm");    
  535. X                break;
  536. X        case '8' :    MAXX = 80;
  537. X                MAXY = 24;
  538. X                wBS = 8; wDEL = 9152; wINS = 9151; wEND = 9189;
  539. X                strcpy(terminal, (unsigned char *) "ansi");
  540. X                strcpy(umlaut, (unsigned char *) "ibm");    
  541. X                break;
  542. X        case '9' :    MAXX = 80;
  543. X                MAXY = 23;
  544. X                wBS = 8; wDEL = 9152; wINS = 9151; wEND = 9189;
  545. X                strcpy(terminal, (unsigned char *) "ansi");
  546. X                strcpy(umlaut, (unsigned char *) "ibm");    
  547. X                break;
  548. X    }
  549. X    ctrls_output();
  550. X  }while(isin("123456789", c) != 0);
  551. X
  552. X  home = (unsigned char *) getenv( "HOME" );
  553. X  sprintf(s, "%s/.wendy", home);
  554. X  fp = fopen( s, "w" );
  555. X  if(fp != 0){
  556. X    fprintf(fp, "%d%c%c%c# Anzahl der Zeilen (4-24)\n", MAXY, TAB, TAB, TAB);
  557. X    fprintf(fp, "%d%c%c%c# Anzahl der Zeichen pro Zeile (10-136)\n", MAXX, TAB, TAB, TAB);
  558. X    fprintf(fp, "%s%c%c%c# Terminal-Emulation (ANSI, VT100, MINIX)\n", terminal, TAB, TAB, TAB);
  559. X     fprintf(fp, "%s%c%c%c# Umlaut-Konvertierung (IBM, ISO-8859-1)\n", umlaut, TAB, TAB, TAB);
  560. X    fprintf(fp, "%d%c%c%c# BS Taste (8 o. 127)\n", wBS, TAB, TAB, TAB);
  561. X    fprintf(fp, "%d%c%c%c# DEL Taste\n", wDEL, TAB, TAB, TAB);
  562. X    fprintf(fp, "%d%c%c%c# INS Taste\n", wINS, TAB, TAB, TAB);
  563. X    fprintf(fp, "%d%c%c%c# END Taste\n", wEND, TAB, TAB, TAB);
  564. X    fclose(fp);
  565. X  }  
  566. X
  567. X#else
  568. X
  569. X  show_status( " WENDY: Changing settings ... " );
  570. X  
  571. X  ansi2( "cm",  1,  3 ); printf("Active Settings:");
  572. X
  573. X  ansi( "mr" );
  574. X  ansi2( "cm",  1,  5 ); printf(" 1 ");
  575. X  ansi2( "cm",  5,  5 ); printf(" Characters per Line " );
  576. X  ansi2( "cm",  1,  7 ); printf(" 2 ");
  577. X  ansi2( "cm",  5,  7 ); printf(" Number of Lines     " );
  578. X
  579. X  ansi2( "cm", 40,  5 ); printf(" 3 ");
  580. X  ansi2( "cm", 44,  5 ); printf(" Terminal-Emulation  " );
  581. X  ansi2( "cm", 40,  7 ); printf(" 4 " );
  582. X  ansi2( "cm", 44,  7 ); printf(" 'Umlaut'-Conversion " );
  583. X
  584. X  ansi( "me" );
  585. X  ansi2( "cm",  1, 10); printf("Predefined Settings:");
  586. X  
  587. X  ansi( "mr" );
  588. X  ansi2( "cm",  1, 12); printf(" 5 ");
  589. X  ansi2( "cm",  5, 12); printf(" UNIX (Console)          ");
  590. X  ansi2( "cm",  1, 14); printf(" 6 ");
  591. X  ansi2( "cm",  5, 14); printf(" MINIX (Console)         ");
  592. X  ansi2( "cm",  1, 16); printf(" 7 ");
  593. X  ansi2( "cm",  5, 16); printf(" DOS (ProComm 2.4.1)     ");
  594. X  
  595. X  ansi2( "cm", 40, 12); printf(" 8 ");
  596. X  ansi2( "cm", 44, 12); printf(" DOS (TELIX  3.11)       ");
  597. X  ansi2( "cm", 40, 14); printf(" 9 ");
  598. X  ansi2( "cm", 44, 14); printf(" DOS (Telemate 2.11)     ");
  599. X
  600. X  ctrls_output();
  601. X  do{                                                            
  602. X        ansi2( "cm", 1, 19); printf("Now, which one do you want ?    ");
  603. X    ansi2( "cm", 30, 19 );
  604. X    c = getch();
  605. X    ansi2( "cm", 1, 19 );
  606. X    switch(c){
  607. X        case '1' :    ansi( "ce" );
  608. X                printf("Characters per line (10-136): ");
  609. X                sprintf(s, "%d", MAXX);
  610. X                strcpy(s, (unsigned char *) getline( 3, 1101, '.', s));
  611. X                MAXX = atoi(s);
  612. X                break;
  613. X        case '2' :    ansi( "ce" );
  614. X                printf("Screenlines (4-24): ");
  615. X                sprintf(s, "%d", MAXY);
  616. X                strcpy(s, (unsigned char *) getline( 2, 1101, '.', s));
  617. X                MAXY = atoi(s);
  618. X                break;
  619. X        case '3' :    ansi( "mr" );
  620. X                ansi2( "cm",  1, 21); printf(" A ");
  621. X                ansi2( "cm",  5, 21); printf(" ANSI (X3.64)  ");
  622. X                ansi2( "cm", 30, 21); printf(" B ");
  623. X                ansi2( "cm", 34, 21); printf(" DEC VT100     "); 
  624. X                ansi2( "cm", 60, 21); printf(" C ");
  625. X                ansi2( "cm", 64, 21); printf(" MINIX CONSOLE ");
  626. X                ansi( "me" );
  627. X
  628. X                ansi2( "cm", 1, 19 ); ansi( "ce" );
  629. X                printf("Terminal-Emulation (A-C): ");
  630. X
  631. X                do{
  632. X                    d = getch();
  633. X                }while(isin("abcABC", d) == 0);
  634. X    
  635. X                switch(d){
  636. X                    case 'a' :
  637. X                    case 'A' :    strcpy(terminal, (unsigned char *) "ansi");
  638. X                            break;
  639. X                    case 'b' :
  640. X                    case 'B' :    strcpy(terminal, (unsigned char *) "vt100");
  641. X                            break;
  642. X                    case 'c' :
  643. X                    case 'C' :    strcpy(terminal, (unsigned char *) "minix");
  644. X                            break;
  645. X                }        
  646. X                ansi2( "cm",  1, 21); ansi( "ce" );    
  647. X                break;
  648. X        case '4' :    ansi( "mr" );
  649. X                ansi2( "cm",  1, 21); printf(" A ");
  650. X                ansi2( "cm",  5, 21); printf(" ISO-8859-1  ");
  651. X                ansi2( "cm", 30, 21); printf(" B ");
  652. X                ansi2( "cm", 34, 21); printf(" IBM-Conversion "); 
  653. X                ansi( "me" );
  654. X
  655. X                ansi2( "cm", 1, 19 ); ansi( "ce" );
  656. X                printf("'Umlaut'-Conversions (A-B): ");
  657. X
  658. X                do{
  659. X                    d = getch();
  660. X                }while(isin("abAB", d) == 0);
  661. X    
  662. X                switch(d){
  663. X                    case 'a' :
  664. X                    case 'A' :    strcpy(umlaut, (unsigned char *) "iso-8859-1");
  665. X                            break;
  666. X                    case 'b' :
  667. X                    case 'B' :    strcpy(umlaut, (unsigned char *) "ibm");
  668. X                            break;
  669. X                }        
  670. X                ansi2( "cm",  1, 21); ansi( "ce" );    
  671. X                break;
  672. X        case '5' :    MAXX = 80;
  673. X                MAXY = 24;
  674. X                strcpy(terminal, (unsigned char *) "vt100");
  675. X                strcpy(umlaut, (unsigned char *) "iso-8859-1");    
  676. X                break;
  677. X        case '6' :    MAXX = 80;
  678. X                MAXY = 24;
  679. X                strcpy(terminal, (unsigned char *) "minix");
  680. X                strcpy(umlaut, (unsigned char *) "ibm");    
  681. X                break;
  682. X        case '7' :    MAXX = 79;
  683. X                MAXY = 24;
  684. X                strcpy(terminal, (unsigned char *) "ansi");
  685. X                strcpy(umlaut, (unsigned char *) "ibm");    
  686. X                break;
  687. X        case '8' :    MAXX = 80;
  688. X                MAXY = 24;
  689. X                strcpy(terminal, (unsigned char *) "ansi");
  690. X                strcpy(umlaut, (unsigned char *) "ibm");    
  691. X                break;
  692. X        case '9' :    MAXX = 80;
  693. X                MAXY = 23;
  694. X                strcpy(terminal, (unsigned char *) "ansi");
  695. X                strcpy(umlaut, (unsigned char *) "ibm");    
  696. X                break;
  697. X    }
  698. X    ctrls_output();
  699. X  }while(isin("123456789", c) != 0);
  700. X
  701. X  home = (unsigned char *) getenv( "HOME" );
  702. X  sprintf(s, "%s/.wendy", home);
  703. X  fp = fopen( s, "w" );
  704. X  if(fp != 0){
  705. X    fprintf(fp, "%d%c%c%c# Number of lines (4-24)\n", MAXY, TAB, TAB, TAB);
  706. X    fprintf(fp, "%d%c%c%c# Characters per line (10-136)\n", MAXX, TAB, TAB, TAB);
  707. X    fprintf(fp, "%s%c%c%c# Terminal-Emulation (ANSI, VT100, MINIX)\n", terminal, TAB, TAB, TAB);
  708. X     fprintf(fp, "%s%c%c%c# 'Umlaut'-Conversion (IBM, ISO-8859-1)\n", umlaut, TAB, TAB, TAB);
  709. X    fclose(fp);
  710. X  }  
  711. X
  712. X#endif
  713. X
  714. X  ansi( terminal, -1, -1 );
  715. X
  716. X  ansi( "cl" );
  717. X  show_status( version );
  718. X  prep_screen( ypos );
  719. X  show_screen( START );
  720. X  x = 1; y = START;
  721. X  ansi2( "cm", x, y );
  722. X}
  723. X/* #CT - Delete from cursor position to eoln */
  724. Xctrlt()
  725. X{
  726. X  unsigned char s[LONGSTRING];
  727. X  strcpy(s, (unsigned char *) SCREEN[y]);
  728. X  s[(x-1)] = '\0';
  729. X  strcat(s, "            ");
  730. X  s[MAXX] = '\0';
  731. X  strcpy(SCREEN[y], (unsigned char *) s);
  732. X  strcpy(s, (unsigned char *) ATTRIB[y]);
  733. X  s[x] = '\0';
  734. X  strcat(s, "0000000000000000000000000000000000000000000000000000000000000000000000000000000");
  735. X  s[MAXX] = '\0';
  736. X  strcpy(ATTRIB[y], (unsigned char *) s);
  737. X  show_line( SCREEN[y], ATTRIB[y], 1 ); /* 1 !!! */
  738. X  ansi2( "cm", x, y );
  739. X}
  740. X/* #CW - Save the text in a file */
  741. Xctrlw( f )
  742. Xunsigned char f[];
  743. X{
  744. X  FILE *fp;
  745. X  int i;
  746. X  int rtf = 0;
  747. X  unsigned char s[STRING];
  748. X  unsigned char q[LONGSTRING]; 
  749. X
  750. X  restore_screen( ypos );
  751. X
  752. X  if(BLOCK.status == BLOCKMODE){
  753. X    block_ctrlw();
  754. X    return;
  755. X  }
  756. X  strcpy(q, (unsigned char *) TEXT[lastline]);
  757. X  while((strlen((unsigned char *) right_stripped(q)) < 2) && (TEXT[lastline][0] < 33)){
  758. X        lastline--;
  759. X    strcpy(q, (unsigned char *) TEXT[lastline]);
  760. X  }
  761. X  fp = fopen( f, "w" );
  762. X
  763. X  if(REALLY != 0){
  764. X        fprintf(fp, "Content-Type: text/richtext;\n");
  765. X        rtf++;
  766. X  } 
  767. X
  768. X  for( i = START; i <= lastline; i++){
  769. X
  770. X        if(TEXT[i][0] == '~'){
  771. X                strcpy(TEXT[i], (unsigned char *) strcopy(TEXT[i], 1, strlen(TEXT[i])));
  772. X        }
  773. X
  774. X    if(((FLAG[i] & is_richtext) == is_richtext) && (rtf == 0)){
  775. X        fprintf(fp, "Content-Type: text/richtext; charset=iso-8859-1\n");
  776. X        rtf++;
  777. X    }
  778. X
  779. X    if(((FLAG[i] & is_plain) == is_plain) && (rtf != 0)){
  780. X        fprintf(fp, "Content-Type: text/plain; charset=iso-8859-1\n");
  781. X        rtf = 0;
  782. X    }
  783. X
  784. X    if((FLAG[i] & is_centered) == is_centered){
  785. X        fprintf(fp, "<center>%s</center>", (unsigned char *) stripped(TEXT[i]));
  786. X    }
  787. X    else{
  788. X        strcpy(q, (unsigned char *) TEXT[i]);
  789. X        strcpy(q, (unsigned char *) right_stripped(q));
  790. X        fputs(q, fp);
  791. X    }
  792. X        if(TEXT[(i+1)][0] != '~'){
  793. X                if(rtf == 0)
  794. X                        fprintf(fp, "\n");
  795. X                else
  796. X                        fprintf(fp, "<nl>\n");
  797. X        }
  798. X  }
  799. X
  800. X  if(rtf != 0){
  801. X        fprintf(fp, "Content-Type: text/plain;\n");
  802. X  } 
  803. X
  804. X  fclose(fp);
  805. X
  806. X  CHANGED = 0;
  807. X
  808. X#ifdef _LOCAL 
  809. X  sprintf(s, " WENDY: Datei <%s> mit %d Zeilen gesichert. ", f, lastline);
  810. X#else
  811. X  sprintf(s, " WENDY: File <%s> with %d lines saved. ", f, lastline);
  812. X#endif
  813. X
  814. X  show_status( s );
  815. X  activate( RTF_attrib );
  816. X  ansi2( "cm", x, y );
  817. X}
  818. X/* #CX - Stop session and leave */
  819. Xctrlx( f )
  820. X{
  821. X  int c;
  822. X  if(CHANGED != 0){
  823. X        printf("%c", 7);
  824. X#ifdef _LOCAL
  825. X        show_status( " WENDY: Datei noch nicht gesichert! Sichern? (J/N) " );
  826. X#else
  827. X    show_status( " WENDY: File not saved yet! Save? (Y/N) " );
  828. X#endif
  829. X        ansi( "mr" );
  830. X        c = yesno();
  831. X        ansi( "me" );
  832. X        if((c == 'J') || (c == 'Y')) ctrlw( f );
  833. X  }
  834. X  show_status( " WENDY: Bye, bye ... " );
  835. X}
  836. X/* #CY - Delete a line */
  837. Xctrly()
  838. X{
  839. X  int i, j, ymem = y;
  840. X
  841. X  if(BLOCK.status == BLOCKMODE){
  842. X    block_ctrly();
  843. X    return;
  844. X  }
  845. X  restore_screen( ypos );
  846. X  j = ypos + y - 1;
  847. X  for(i = j; i < lastline; i++){
  848. X        strcpy(TEXT[i], (unsigned char *) TEXT[i+1]);
  849. X    FLAG[i] = FLAG[i+1];
  850. X  }
  851. X  lastline--;
  852. X  prep_screen( ypos );
  853. X
  854. X  if(ansi( "dl" ) != 0){
  855. X    show_screen( y );
  856. X  }
  857. X  else{
  858. X    y = MAXY;
  859. X    show_line( SCREEN[MAXY], ATTRIB[MAXY], 1 );
  860. X    y = ymem;
  861. X    ansi2( "cm", x, y );
  862. X  }
  863. X}
  864. X
  865. END_OF_FILE
  866.   if test 21334 -ne `wc -c <'mbox/contrib/wendy/ctrl.c'`; then
  867.     echo shar: \"'mbox/contrib/wendy/ctrl.c'\" unpacked with wrong size!
  868.   fi
  869.   # end of 'mbox/contrib/wendy/ctrl.c'
  870. fi
  871. if test -f 'mbox/src/intro.c' -a "${1}" != "-c" ; then 
  872.   echo shar: Will not clobber existing file \"'mbox/src/intro.c'\"
  873. else
  874.   echo shar: Extracting \"'mbox/src/intro.c'\" \(18265 characters\)
  875.   sed "s/^X//" >'mbox/src/intro.c' <<'END_OF_FILE'
  876. X/* ix/MBox (admin.c) by Volker Schuermann, 04.12.1993
  877. X
  878. X   This C source code contains the following functions:
  879. X
  880. X   #IN intro()             show intros, handle login
  881. X   #IU init_user()         activate users preferences
  882. X
  883. X   Contact <volkers@unnet.wupper.de> for help! */
  884. X
  885. X
  886. X
  887. X
  888. X
  889. X
  890. X
  891. X
  892. X
  893. X#include <sys/types.h>
  894. X#include <sys/stat.h>
  895. X#include <unistd.h>
  896. X#include <fcntl.h>
  897. X#include <stdio.h>
  898. X#include <time.h>
  899. X
  900. X#include "mbox.h"
  901. X
  902. Xtime_t time_start, time_now;
  903. X
  904. X
  905. Xvoid init_user();
  906. X
  907. X
  908. X
  909. X/* #IN - Welcome users, show intros, handle login. */
  910. X
  911. Xvoid intro()
  912. X{
  913. X  FILE *fp;
  914. X  FILE *ff;
  915. X  int fd;
  916. X  UNSIGNED char s[LSTRING];
  917. X  UNSIGNED char t[STRING];
  918. X  UNSIGNED char f[STRING];
  919. X  UNSIGNED char tmp[STRING];
  920. X  UNSIGNED char crypt_pw[STRING];
  921. X  UNSIGNED char ex[LONGSTRING];
  922. X  UNSIGNED char tmpuser[STRING];
  923. X  UNSIGNED char moreLASTLOG[STRING];
  924. X  UNSIGNED char teca[4][STRING];
  925. X  
  926. X  UNSIGNED char *term;  
  927. X  UNSIGNED char c;  
  928. X
  929. X  int i, calls;
  930. X  int ok;
  931. X  int a, b;
  932. X  long ll, lalo;
  933. X  struct userdaten LOOSER;
  934. X
  935. X  struct tm *timeptr;
  936. X  time_t timer;
  937. X  struct stat fst;
  938. X
  939. X  umask(0007);
  940. X
  941. X  term = (UNSIGNED char *) getenv("TERM");
  942. X  strcpy(TERMINAL, (UNSIGNED char *) term);
  943. X
  944. X  ansi2("INIT", 0, 0);
  945. X  ansi2("me", 0, 0 );
  946. X
  947. X  time(&time_start);
  948. X
  949. X  fp = fopen( LOGO, "r" );
  950. X  if(fp != NULL){
  951. X    fclose(fp);
  952. X    printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
  953. X    ansi2("cl", 0, 0);
  954. X    ansi2("md", 0, 0);
  955. X    show( LOGO, 9999, 0 );
  956. X    ansi2("me", 0, 0);
  957. X    c = getint();    
  958. X  }
  959. X
  960. X  printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
  961. X  ansi2("cl", 0, 0);
  962. X
  963. X  ansi2("md", 0, 0);
  964. X  printf("\n%s ", INT01_MSG);
  965. X  ansi2("me", 0, 0);
  966. X  printf("%s", ORGANIZATION);
  967. X    
  968. X  ansi2("md", 0, 0);
  969. X  printf("\n%s ", INT02_MSG);
  970. X  ansi2("me", 0, 0);
  971. X  printf("%s %s %s", VERSION, PATCHLEVEL, AUTOR);
  972. X
  973. X  ansi2("md", 0, 0);
  974. X  printf("\n%s ", INT03_MSG);
  975. X  ansi2("me", 0, 0);
  976. X  printf("%s", SYSTEM);
  977. X
  978. X  BAUDRATE = (int) 0;
  979. X
  980. X
  981. X  fp = fopen( TERMIS, "r" );
  982. X  if(fp == NULL){
  983. X    nerror("intro.c", 158, "intro", "Can't read", TERMIS);
  984. X  }
  985. X  while((fgets(s, STRING, fp) != 0) && (s[0] != '='));
  986. X
  987. X  fgets(s, STRING, fp); sscanf(s, "%s", TECA[1].entry);
  988. X  strcpy(TECA[1].name, (UNSIGNED char *) upcased( TECA[1].entry));
  989. X  strcpy(TECA[1].desc, (UNSIGNED char *) stripped( strcopy( s, strlen(TECA[1].entry), STRING)));
  990. X  fgets(s, STRING, fp); sscanf(s, "%s", TECA[2].entry);
  991. X  strcpy(TECA[2].name, (UNSIGNED char *) upcased( TECA[2].entry));
  992. X  strcpy(TECA[2].desc, (UNSIGNED char *) stripped( strcopy( s, strlen(TECA[2].entry), STRING)));
  993. X  fgets(s, STRING, fp); sscanf(s, "%s", TECA[3].entry);
  994. X  strcpy(TECA[3].name, (UNSIGNED char *) upcased( TECA[3].entry));
  995. X  strcpy(TECA[3].desc, (UNSIGNED char *) stripped( strcopy( s, strlen(TECA[3].entry), STRING)));
  996. X  fclose(fp);
  997. X
  998. X
  999. X  if (OLDGID == GUEST_GID) {    /* GUESTS / GAESTE */
  1000. X
  1001. X        TRY_AGAIN:
  1002. X
  1003. X    printf("\n\n%s ", GBL04_MSG);
  1004. X    strcpy(LOOSER.name, (UNSIGNED char *) getline(30, 11, '.', ""));
  1005. X    if (LOOSER.name[0] == '\0') goto TRY_AGAIN;
  1006. X
  1007. X    strcpy(s, (UNSIGNED char *) upcased(LOOSER.name));
  1008. X
  1009. X    if (strcomp(GUEST, s) != 0) {
  1010. X
  1011. X        printf("\n%s ", GBL09_MSG);
  1012. X        strcpy(LOOSER.passwort, (UNSIGNED char *) getline(10, 12, '.', ""));
  1013. X        strcpy(crypt_pw, (UNSIGNED char *) crypted(LOOSER.passwort));
  1014. X
  1015. X        maybe_locked(UDBASE, "r"); mblock(UDBASE);
  1016. X        fd = open(UDBASE, O_RDONLY);
  1017. X        if (fd == -1) {
  1018. X            nerror("intro.c", 78, "intro", "Can't read", UDBASE);
  1019. X        }
  1020. X        ok = 0;
  1021. X        while ((ok == 0) && (read(fd, (UNSIGNED char *) &USER, sizeof(USER)) == sizeof(USER))) {
  1022. X            if ((strcomp(LOOSER.name, USER.name) == 0) ||
  1023. X                (strcomp(LOOSER.name, USER.nick) == 0)) {
  1024. X                if ((strcomp(USER.passwort, (UNSIGNED char *) crypt_pw) == 0) ||
  1025. X                        (strcomp(USER.passwort, LOOSER.passwort) == 0))
  1026. X                    ok = 1;
  1027. X            }
  1028. X        }
  1029. X        close(fd);
  1030. X        mbunlock(UDBASE);
  1031. X
  1032. X        if (ok == 1) goto WELL_DONE;
  1033. X        goto TRY_AGAIN;
  1034. X    }
  1035. X    strcpy(LOOSER.name, (UNSIGNED char *) upcased(s));
  1036. X
  1037. X    maybe_locked(UDBASE, "r"); mblock(UDBASE);
  1038. X    fd = open(UDBASE, O_RDONLY);
  1039. X    if (fd == -1) {
  1040. X        nerror("intro.c", 98, "intro", "Can't read", UDBASE);
  1041. X    }
  1042. X    ok = 0;
  1043. X    while ((ok == 0) && (read(fd, (UNSIGNED char *) &USER, sizeof(USER)) == sizeof(USER))) {
  1044. X        if (strcomp(LOOSER.name, USER.name) == 0) ok = 1;
  1045. X    }
  1046. X    close(fd);
  1047. X    mbunlock(UDBASE);
  1048. X
  1049. X    ansi2("md", 0, 0);
  1050. X    printf("\n\n%s\n\n", INT04_MSG);
  1051. X    ansi2("me", 0, 0);
  1052. X    printf("%s\n\n", INT05_MSG);
  1053. X    printf("%-15.15s  6 - %-12.12s  7 - %-12.12s  8 - %-12.12s\n",
  1054. X         INT05aMSG, TECA[1].name, TECA[2].name, TECA[3].name);
  1055. X
  1056. X    ansi2("md", 0, 0);
  1057. X    printf("\n%s > ", INT06_MSG);
  1058. X    ansi2("me", 0, 0);
  1059. X    printf("5%c", BS);
  1060. X
  1061. X    do {
  1062. X        c = getint();
  1063. X        if((c == LF) || (c == CR)) c = '5';
  1064. X    } while ((c < '1') || (c > '8'));
  1065. X    printf("%c", c);
  1066. X    USER.terminal = c - 48;
  1067. X
  1068. X#ifdef GERMAN_VERSION
  1069. X    ansi2("md", 0, 0);
  1070. X    printf("\n\nWelche der folgenden Umlaut-Darstellungen ist korrekt?\n\n");
  1071. X    ansi2("me", 0, 0);
  1072. X
  1073. X    printf("1 - [%c] [%c] [%c] [%c] [%c] [%c] [%c]  ISO-8859-1 / AMIGA\n\n",
  1074. X        196, 214, 220, 228, 246, 252, 223);
  1075. X    printf("2 - [%c] [%c] [%c] [%c] [%c] [%c] [%c]  IBM / ATARI\n\n",
  1076. X        142, 153, 154, 132, 148, 129, 225);
  1077. X
  1078. X    printf("3 - [Ae] [Oe] [Ue] [ae] [oe] [ue] [ss]\n");
  1079. X
  1080. X    ansi2("md", 0, 0);
  1081. X    printf("\n%s > ", "Und?");
  1082. X    ansi2("me", 0, 0);
  1083. X    printf("2%c", BS);
  1084. X
  1085. X    do {
  1086. X        c = getint();
  1087. X        if((c == LF) || (c == CR)) c = '2';
  1088. X    } while ((c < '1') || (c > '3'));
  1089. X    printf("%c", c);
  1090. X    USER.schluessel[2] = c - 48;
  1091. X
  1092. X#else
  1093. X    USER.schluessel[2] = 4;
  1094. X#endif
  1095. X
  1096. X    strcpy(USER.name, (UNSIGNED char *) GUEST);
  1097. X    sprintf(USER.passwort, "%s", "*****");
  1098. X
  1099. X    USER.level       =   0;
  1100. X    USER.prompt        =   2;
  1101. X    USER.bell          =   0;
  1102. X    USER.intro         =   1;
  1103. X    USER.more          =   3;
  1104. X    USER.lastmode      =   2;
  1105. X    USER.leserichtung  =   2;
  1106. X    USER.tlines        =  22;
  1107. X    USER.schluessel[0] =   1;
  1108. X    USER.schluessel[1] =   3;
  1109. X    USER.schluessel[3] = 128;
  1110. X
  1111. X    if(USER.terminal < 2) 
  1112. X            USER.editor = 1;
  1113. X    else
  1114. X            USER.editor = 2;
  1115. X
  1116. X    sprintf(USER.newsgrps, "%s", NEWS_MINIMUM);
  1117. X
  1118. X    LASTLOG = (long) 19700101;
  1119. X    LASTTIME = 0;
  1120. X    sprintf(moreLASTLOG, "%s", "01.01.1970");
  1121. X  }
  1122. X  else {            /* USER */
  1123. X
  1124. X    printf("\n\n%s ....................", GBL04_MSG);
  1125. X    for (i = 0; i < 20; i++) printf("%c", BS);
  1126. X
  1127. X    strcpy(tmpuser, (UNSIGNED char *) whoami());
  1128. X    printf("%s", tmpuser);
  1129. X
  1130. X    printf("\n%s ..........", GBL09_MSG);
  1131. X
  1132. X    for (i = 0; i < 10; i++) printf("%c", BS);
  1133. X    for (i = 0; i < 10; i++) printf("*");
  1134. X
  1135. X    if (strcomp(tmpuser, "root") == 0) {
  1136. X        strcpy(tmpuser, (UNSIGNED char *) POSTMASTER);
  1137. X
  1138. X        strcpy(s, (UNSIGNED char *) ttyname(0));
  1139. X        if((PMS_TTY[0] != '\0') && (strcomp(PMS_TTY, s) != 0)){
  1140. X            printf("\n\n");
  1141. X            ansi2("mr", 0, 0);
  1142. X            printf("%s \"%s\" %s", INT07_MSG, PMS_TTY, INT07aMSG);
  1143. X            ansi2("me", 0, 0);
  1144. X            printf("\n\n");
  1145. X            exit(-1);
  1146. X        }
  1147. X        else {
  1148. X            USER.level = 10;
  1149. X        }
  1150. X    }
  1151. X    maybe_locked(UDBASE, "r"); mblock(UDBASE);
  1152. X    fd = open(UDBASE, O_RDONLY);
  1153. X    if (fd == -1) {
  1154. X        nerror("intro.c", 156, "intro", "Can't read", UDBASE);
  1155. X    }
  1156. X    ok = 0;
  1157. X    while ((ok == 0) && (read(fd, (UNSIGNED char *) &USER, sizeof(USER)) == sizeof(USER))) {
  1158. X        if ((strcomp(tmpuser, USER.sh_name) == 0)) ok = 1;
  1159. X    }
  1160. X    close(fd);
  1161. X    mbunlock(UDBASE);
  1162. X
  1163. X    if (ok == 0) postfach(tmpuser);
  1164. X
  1165. X  }
  1166. X
  1167. X  WELL_DONE:
  1168. X
  1169. X  printf("\n\n%s ...", INT09aMSG);
  1170. X
  1171. X  setuid( ROOT_UID );
  1172. X  setgid( ROOT_GID ); 
  1173. X
  1174. X  if(USER.name[0] > 96) USER.name[0] -= 32;
  1175. X
  1176. X  if (strcomp(GUEST, USER.name) != 0) {
  1177. X    LASTLOG = (long) dateconv(USER.lastlog);
  1178. X    LASTTIME = USER.lasttime;
  1179. X    sprintf(moreLASTLOG, "%s", USER.lastlog);
  1180. X  }
  1181. X  if (USER.lastmode == 2) LASTTIME = 0;
  1182. X
  1183. X  sprintf(s, "%s/usr/%c/%d/.dummy", HOME, USER.name[0], USER.id); /* New User-Directory !!! */
  1184. X  fp = fopen( s, "w" );
  1185. X  if(fp == NULL){
  1186. X    sprintf(s, "%s/usr/%c", HOME, USER.name[0]);
  1187. X#ifndef _LINUX
  1188. X    mkdir( s );
  1189. X    chmod( s, 0777 );
  1190. X#else
  1191. X    mkdir( s, 0777 );
  1192. X#endif
  1193. X    sprintf(s, "%s/usr/%c/%d", HOME, USER.name[0], USER.id);
  1194. X#ifndef _LINUX
  1195. X    mkdir( s );
  1196. X    chmod(s , 0777 );
  1197. X#else
  1198. X    mkdir(s, 0777 );
  1199. X#endif
  1200. X    sprintf(s, "cp %s/usr/%d/.* %s/usr/%c/%d > /dev/null 2>&1", HOME, USER.id, HOME, USER.name[0], USER.id);
  1201. X    system( s );
  1202. X    sprintf(s, "cp %s/usr/%d/* %s/usr/%c/%d > /dev/null 2>&1", HOME, USER.id, HOME, USER.name[0], USER.id);
  1203. X    system( s );
  1204. X    sprintf(s, "rm -r %s/usr/%d", HOME, USER.id);
  1205. X    system( s );
  1206. X  }
  1207. X  else{
  1208. X    unlink(s);
  1209. X    fclose(fp);  
  1210. X  }
  1211. X
  1212. X  sprintf(s, "%s \"%s\" (%d) %s", INT08_MSG, USER.name, USER.id, INT09_MSG);
  1213. X  control(s, 3);
  1214. X  whodo( INT10_MSG );
  1215. X  if ((USER.level < 10) && (strcomp(MYNAME, USER.name) != 0)) {
  1216. X
  1217. X    maybe_locked(SEQ, "r"); mblock(SEQ);
  1218. X    fp = fopen(SEQ, "r");
  1219. X    if (fp == NULL) {
  1220. X        nerror("intro.c", 223, "intro", "Can't read", SEQ);
  1221. X    }
  1222. X    fscanf(fp, "%d", &calls);
  1223. X    fclose(fp);
  1224. X    calls++;
  1225. X
  1226. X    fp = fopen(SEQ, "w");
  1227. X    if (fp == NULL) {
  1228. X        nerror("intro.c", 227, "intro", "Can't write to", SEQ);
  1229. X    }
  1230. X    fprintf(fp, "%d\n", calls);
  1231. X    fclose(fp);
  1232. X    mbunlock(SEQ);
  1233. X
  1234. X    sprintf(tmp, "%s/%dT", TMP, getpid());
  1235. X
  1236. X    fp = fopen(tmp, "w");
  1237. X    if (fp == NULL) {
  1238. X        nerror("intro.c", 236, "intro", "Can't write to", tmp);
  1239. X    }
  1240. X    maybe_locked(CALLS, "r"); mblock(CALLS);
  1241. X    ff = fopen(CALLS, "r");
  1242. X    if (ff == NULL) {
  1243. X        nerror("intro.c", 239, "intro", "Can't read", CALLS);
  1244. X    }
  1245. X    sprintf(s, "%s (%s)", USER.name, USER.nick);
  1246. X    strcpy(t, numstripped(USER.wohnort));
  1247. X    if (t[0] == '\0') strcpy(t, (UNSIGNED char *) "   ");
  1248. X
  1249. X    strcpy(f, (UNSIGNED char *) ttyna());
  1250. X
  1251. X    fprintf(fp, "%5.d  %-28.28s  %-17.17s%8.8s  %s  %s\n",
  1252. X        calls, s, (UNSIGNED char *) stripped(t), f, (UNSIGNED char *) mydate(1), (UNSIGNED char *) mytime(1));
  1253. X
  1254. X    if(PRO_ENTRIES < 10){
  1255. X        nerror("intro.c", 291, "intro", "PRO_ENTRIES must be defined bigger", "mbox.h");            
  1256. X    }
  1257. X
  1258. X    i = 1;
  1259. X    while ((fgets(s, STRING, ff) != NULL) && (i <= PRO_ENTRIES)) {
  1260. X        fputs(s, fp);
  1261. X        i++;
  1262. X    }
  1263. X
  1264. X    fclose(fp);
  1265. X    fclose(ff);
  1266. X
  1267. X#ifdef _ALLTIME
  1268. X    if(i >= PRO_ENTRIES){
  1269. X        fp = fopen( ALLTIME, "a" );
  1270. X        if(fp == NULL){
  1271. X            nerror("intro.c", 337, "intro", "Can't append to", ALLTIME);
  1272. X        }
  1273. X        fputs(s, fp);
  1274. X        fclose(fp);
  1275. X    }
  1276. X#endif
  1277. X
  1278. X        mbrename( tmp, CALLS );
  1279. X    unlink(tmp);
  1280. X    mbunlock(CALLS);
  1281. X  }
  1282. X
  1283. X  sprintf(s, "%s/usr/%c/%d/INDEX", HOME, USER.name[0], USER.id);  
  1284. X  if(atol(USER.abused) == 0L){
  1285. X      stat(s, &fst);
  1286. X      IDX_SIZE = (long) fst.st_size;
  1287. X  }
  1288. X  else IDX_SIZE = atol(USER.abused);
  1289. X
  1290. X  stat(MB_READY, &fst);
  1291. X  MBD_SIZE = (int) fst.st_size;  
  1292. X
  1293. X  printf("%c", CR);
  1294. X
  1295. X  init_user( INT11_MSG, 1 );
  1296. X
  1297. X
  1298. X  if(USER.schluessel[3] == 128){
  1299. X    show_raw( ANSI_INTRO, 10 );
  1300. X  }
  1301. X
  1302. X  sprintf(UGROUPS, "%s/usr/%c/%d/.active", HOME, USER.name[0], USER.id);
  1303. X
  1304. X  if (USER.intro < 3) {
  1305. X
  1306. X    a = 0;
  1307. X    fp = fopen(UGROUPS, "r");
  1308. X    if (fp == NULL) {
  1309. X        nerror("intro.c", 283, "intro", "Can't read", AGROUPS);
  1310. X    }
  1311. X    while (fgets(ex, LONGSTRING, fp) != NULL) a++;
  1312. X    fclose(fp);
  1313. X
  1314. X    b = 0;
  1315. X    sprintf(s, "%s/usr/%c/%d/INDEX", HOME, USER.name[0], USER.id);  
  1316. X    
  1317. X    fp = fopen(s, "r");
  1318. X    if (fp == NULL) {
  1319. X        nerror("intro.c", 291, "intro", "Can't read", s);
  1320. X    }
  1321. X    while (fgets(ex, LONGSTRING, fp) != NULL){
  1322. X        if((strlen(ex) > 60) && (ex[5] != '*')) b++;
  1323. X    }
  1324. X    fclose(fp);
  1325. X    b -= 2;
  1326. X
  1327. X    ansi2("md", 0, 0);
  1328. X    printf("%s %d. %s %s %s.\n", 
  1329. X        INT12_MSG, USER.seq, INT13_MSG, moreLASTLOG, INT14_MSG);
  1330. X    printf("%s %d %s %d %s.\n", 
  1331. X        INT15_MSG, a, INT16_MSG, b, INT17_MSG);
  1332. X    ansi2("me", 0, 0);
  1333. X    printf("\n");
  1334. X  }
  1335. X
  1336. X  if ((USER.intro != 2) && (USER.intro != 4)){
  1337. X    a = MAX_SCR_LINES;
  1338. X    if (USER.schluessel[3] == 128)
  1339. X        MAX_SCR_LINES -= 11;
  1340. X        
  1341. X    if (USER.level == GUEST_LEV) {
  1342. X        show(GUESTS_INTRO, 9999, USER.more);
  1343. X        printf("\n");
  1344. X    }
  1345. X    show(INTRO, 9999, USER.more);
  1346. X
  1347. X    MAX_SCR_LINES = a;
  1348. X  }
  1349. X  
  1350. X  fp = fopen(WHO, "a");
  1351. X  if (fp == NULL) {
  1352. X    nerror("intro.c", 309, "intro", "Can't read", WHO);
  1353. X  }
  1354. X  strcpy(s, (UNSIGNED char *) USER.sh_name);
  1355. X  if (s[0] == '\0') strcpy(s, (UNSIGNED char *) USER.nick);
  1356. X  if (s[0] == '\0') strcpy(s, (UNSIGNED char *) GBL10_MSG);
  1357. X  sprintf(ex, "%-8.8s %s (%s)                                               ",
  1358. X    (UNSIGNED char *) ttyna(), USER.name, s);
  1359. X
  1360. X  ex[39] = '\0';
  1361. X  fputs(ex, fp);
  1362. X
  1363. X  sprintf(ex, "%8.8s", (UNSIGNED char *) ttyna());
  1364. X  fputs(ex, fp);
  1365. X
  1366. X  strcpy(s, (UNSIGNED char *) mytime(1));
  1367. X  if (USER.level < 10)
  1368. X    sprintf(ex, "   %s   [%d] MBox: %s\n", s, USER.level, INT10_MSG);
  1369. X  else
  1370. X    sprintf(ex, "   %s   [%d] MBox: %s\n", s, ADMIN_LEV, INT10_MSG);
  1371. X
  1372. X  fputs(ex, fp);
  1373. X  fclose(fp);
  1374. X  
  1375. X  sprintf(MYNAME, "%s", USER.name);
  1376. X
  1377. X  sprintf(s, "%s", (UNSIGNED char *) mydate(0));
  1378. X  s[6] = '\0';
  1379. X  if (strcomp(s, USER.geburtsdatum) == 0) {
  1380. X    ansi2("md", 0, 0);
  1381. X    printf("\n\n%s\n", INT18_MSG);
  1382. X    printf("%s\n\n", INT19_MSG);
  1383. X    ansi2("me", 0, 0);
  1384. X  }
  1385. X  if (strcomp("24.12.", s) == 0) {
  1386. X    ansi2("md", 0, 0);
  1387. X    printf("\n\n%s\n", INT20_MSG);
  1388. X    printf("%s\n\n", INT21_MSG);
  1389. X    ansi2("me", 0, 0);
  1390. X  }
  1391. X  if (strcomp("06.12.", s) == 0) {
  1392. X    ansi2("md", 0, 0);
  1393. X    printf("\n\n%s\n", INT22_MSG);
  1394. X    printf("\n%s\n\n", INT23_MSG);
  1395. X    ansi2("me", 0, 0);
  1396. X  }
  1397. X  if (strcomp("01.01.", s) == 0) {
  1398. X    ansi2("md", 0, 0);
  1399. X    printf("\n\n%s\n", INT24_MSG);
  1400. X    printf("%s\n\n", INT25_MSG);
  1401. X    ansi2("me", 0, 0);
  1402. X  }
  1403. X  if ((calls == 1000) || (calls == 10000) || (calls == 100000)) {
  1404. X    ansi2("md", 0, 0);
  1405. X    printf("\n\n%s %d%s\n\n", INT26_MSG, calls, INT27_MSG);
  1406. X    ansi2("me", 0, 0);
  1407. X  }
  1408. X
  1409. X
  1410. X  /* Strict Accounting ... decrease Level if User doesn't pay */
  1411. X
  1412. X  strcpy(s, (UNSIGNED char *) mydate( 0 ));
  1413. X  lalo = dateconv(s);  
  1414. X  
  1415. X  strcpy(s, (UNSIGNED char *) USER.account);
  1416. X  s[10] = '\0';
  1417. X  ll = dateconv(s);
  1418. X
  1419. X  if((ll <= lalo) && (ll > 19000000L)){
  1420. X    ansi2( "md", 0, 0 );
  1421. X    printf("\n%s %s %s\n", INT28_MSG, s, INT29_MSG);
  1422. X    ansi2( "me", 0, 0 );
  1423. X    printf("%s\n", INT30_MSG);
  1424. X
  1425. X    if(lalo > (ll + 14)){
  1426. X        USER.level = PD_U_LEV;
  1427. X        sprintf(USER.newsgrps, "%s", NEWS_MINIMUM);        
  1428. X    }
  1429. X  }
  1430. X
  1431. X  if(USER.level >= ADMIN_LEV){
  1432. X    sprintf(s, "%s/core", HOME);
  1433. X    fp = fopen( s, "r" );
  1434. X    if(fp != NULL){
  1435. X        fclose(fp);
  1436. X        stat(s, &fst);
  1437. X        timeptr = localtime( &fst.st_mtime );
  1438. X
  1439. X        printf("\n%s %02.2d.%02.2d.%04.4d %s %02.2d:%02.2d %s\n",
  1440. X            INT31_MSG,
  1441. X            timeptr->tm_mday, timeptr->tm_mon, 1900 + timeptr->tm_year,
  1442. X            INT32_MSG,
  1443. X            timeptr->tm_hour, timeptr->tm_min,
  1444. X            INT33_MSG );
  1445. X        unlink(s);
  1446. X    }
  1447. X  }
  1448. X
  1449. X  uptodate();
  1450. X}
  1451. X
  1452. X
  1453. X
  1454. X/* #IU - Reset users data for this session. 
  1455. X
  1456. X   [info] contains a text, which is shown during the process,
  1457. X   [mode] if set to 1 will start a complete rebuild. */ 
  1458. X
  1459. Xvoid init_user(info, mode)
  1460. XUNSIGNED char info[];
  1461. Xint mode;
  1462. X{
  1463. X  FILE *fp;
  1464. X  FILE *ff;
  1465. X  FILE *fl;
  1466. X  int fd;
  1467. X  UNSIGNED char s[STRING];
  1468. X  UNSIGNED char t[STRING];
  1469. X  int i;
  1470. X  struct userdaten DUMMY;
  1471. X  int dummy = sizeof(DUMMY);
  1472. X  long ll, lalo;
  1473. X  int lati;
  1474. X  int ok;
  1475. X
  1476. X  printf("%s ..", info);
  1477. X
  1478. X
  1479. X  switch (USER.terminal) {
  1480. X      case 1:    sprintf(TERMINAL, "ansi");
  1481. X        break;
  1482. X      case 2:    sprintf(TERMINAL, "vt100");
  1483. X        break;
  1484. X      case 3:    sprintf(TERMINAL, "vt52");
  1485. X        break;
  1486. X      case 4:    sprintf(TERMINAL, "un");
  1487. X        break;
  1488. X      case 5:   sprintf(TERMINAL, "ansi-color");
  1489. X        break;    
  1490. X      case 6:    sprintf(TERMINAL, TECA[1].entry);
  1491. X        break;
  1492. X      case 7:     sprintf(TERMINAL, TECA[2].entry);
  1493. X        break;
  1494. X      case 8:    sprintf(TERMINAL, TECA[3].entry);
  1495. X  }
  1496. X  printf(".");
  1497. X
  1498. X  sprintf(s, "[TERMINAL:] %s", TERMINAL);
  1499. X  control(s, 3);
  1500. X
  1501. X  ansi2("INIT", 0, 0);
  1502. X
  1503. X  fp = fopen(EDITORS, "r");
  1504. X  if (fp == NULL) {
  1505. X    nerror("intro.c", 487, "intro", "Can't read", EDITORS);
  1506. X  }
  1507. X  i = 0;
  1508. X  while((fgets(s, STRING, fp) != NULL) && (s[0] != '='));
  1509. X
  1510. X  while (fscanf(fp, "%s %s", t, s) > 0){
  1511. X    if(i == (USER.editor -1)) strcpy(EDDY, (UNSIGNED char *) s);
  1512. X    i++;
  1513. X  }
  1514. X  fclose(fp);
  1515. X
  1516. X  OFFERED_EDITORS = i;
  1517. X
  1518. X  printf(".");
  1519. X
  1520. X  if (USER.leserichtung == 0) USER.leserichtung = 2;
  1521. X
  1522. X  USER.seq++;
  1523. X
  1524. X  maybe_locked(UDBASE, "r"); mblock(UDBASE);
  1525. X  fd = open(UDBASE, O_RDWR);
  1526. X  if (fd == -1) {
  1527. X    nerror("intro.c", 395, "init_user", "Can't open", UDBASE);
  1528. X  }
  1529. X  while (read(fd, (UNSIGNED char *) &DUMMY, dummy) == dummy) {
  1530. X    if (USER.id == DUMMY.id) {
  1531. X        ll = lseek(fd, 0L, SEEK_CUR) - dummy;
  1532. X    }
  1533. X  }
  1534. X  lseek(fd, ll, SEEK_SET);
  1535. X  write(fd, (UNSIGNED char *) &USER, sizeof(USER));
  1536. X  close(fd);
  1537. X  mbunlock(UDBASE);
  1538. X
  1539. X  printf(".");
  1540. X
  1541. X  if (USER.newsgrps[0] == '\0') sprintf(USER.newsgrps, "%s", NEWS_MINIMUM);
  1542. X
  1543. X  if (strcomp("selected", USER.newsgrps) == 0){
  1544. X
  1545. X    i = 1;
  1546. X    
  1547. X    fp = fopen( SELECTED, "r" );
  1548. X    if(fp == NULL){
  1549. X        nerror("intro.c", 675, "init_user", "Can't open", SELECTED);
  1550. X    }     
  1551. X    while((fgets(s, STRING, fp) != 0) && (i < MAX_NEWSGRPS)){
  1552. X        if((s[0] != '#') && (strlen(s) > 2)){
  1553. X            strcpy(newsgrp[i], (UNSIGNED char *) stripped(s));
  1554. X            i++;
  1555. X        }
  1556. X    }
  1557. X    fclose(fp);    
  1558. X  }
  1559. X  else{
  1560. X    sscanf(USER.newsgrps, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
  1561. X        newsgrp[1], newsgrp[2], newsgrp[3], newsgrp[4], newsgrp[5],
  1562. X        newsgrp[6], newsgrp[7], newsgrp[8], newsgrp[9], newsgrp[10],
  1563. X        newsgrp[11], newsgrp[12], newsgrp[13], newsgrp[14], newsgrp[15]);
  1564. X  }
  1565. X
  1566. X  if (mode == 1) { 
  1567. X
  1568. X    sprintf(UGROUPS, "%s/usr/%c/%d/.active", HOME, USER.name[0], USER.id);
  1569. X    sprintf(SGROUPS, "%s/usr/%c/%d/.active.all", HOME, USER.name[0], USER.id);
  1570. X    sprintf(MAKRO, "%s/usr/%c/%d/.makro", HOME, USER.name[0], USER.id);
  1571. X
  1572. X    maybe_locked( AGROUPS, "r" );
  1573. X    fp = fopen(AGROUPS, "r");
  1574. X    if (fp == NULL) {
  1575. X        nerror("intro.c", 412, "intro", "Can't read", AGROUPS);
  1576. X    }
  1577. X    ff = fopen(UGROUPS, "w");
  1578. X    if (ff == NULL) {
  1579. X        nerror("intro.c", 442, "intro", "Can't write", UGROUPS);
  1580. X    }
  1581. X    fl = fopen(SGROUPS, "w");
  1582. X    if (fl == NULL) {
  1583. X        nerror("intro.c", 545, "intro", "Can't write", SGROUPS);
  1584. X    }
  1585. X
  1586. X    i = 0;
  1587. X
  1588. X    while (fscanf(fp, "%s %ld %d", s, &lalo, &lati) > 0) {
  1589. X        if ((is_subscribed(s) == 1) && (chk_newsgrp(s) == 0)) {
  1590. X            sprintf(t, "%s 00000 00000 y\n", s);
  1591. X            if (LASTLOG < lalo) {
  1592. X                fputs(t, ff);
  1593. X            }
  1594. X            if (LASTLOG == lalo) {
  1595. X                if (LASTTIME <= lati) fputs(t, ff);
  1596. X            }
  1597. X            fputs(t, fl);
  1598. X        }
  1599. X        i++;
  1600. X        if (!(i % 30)) printf(".");
  1601. X      }
  1602. X      fclose(fl);
  1603. X      fclose(ff);
  1604. X      fclose(fp);
  1605. X
  1606. X      printf(".");
  1607. X
  1608. X  }
  1609. X
  1610. X  strcpy(BRETT, "PM");
  1611. X  sprintf(NG, "%s.PM", USER.name);
  1612. X  sprintf(INHALT, "%s/usr/%c/%d/INDEX", HOME, USER.name[0], USER.id);
  1613. X
  1614. X  MAX_SCR_LINES = USER.tlines;
  1615. X
  1616. X  if(USER.schluessel[0] == 32)
  1617. X    SHORT_HEADER = 1;
  1618. X  else
  1619. X    SHORT_HEADER = 0;
  1620. X
  1621. X  if(USER.schluessel[1] == 0)
  1622. X    USER.schluessel[1] = 4;
  1623. X
  1624. X  if(USER.level >= WRITE_INTERNAT){
  1625. X    strcpy(UUCPID, UUCPID2);
  1626. X  }
  1627. X  else{
  1628. X    strcpy(UUCPID, UUCPID1);
  1629. X  }
  1630. X
  1631. X  if((USER.schluessel[2] != 1) && (USER.schluessel[2] != 2) && (USER.schluessel[2] != 4))
  1632. X    USER.schluessel[2] = 3;
  1633. X
  1634. X  UMLAUT_MODUS = USER.schluessel[2];
  1635. X
  1636. X  if(USER.account[0] == '\0') strcpy(USER.account, "00.00.0000");
  1637. X  USER.account[10] = '\0'; 
  1638. X  
  1639. X  if(USER.name[0] >= 'a') USER.name[0] -= 32;
  1640. X
  1641. X  if((USER.schluessel[3] != 128) && (USER.schluessel[3] != 96)){
  1642. X    if(USER.schluessel[2] == INTEL_INSIDE)
  1643. X        USER.schluessel[3] = 128;
  1644. X    else
  1645. X        USER.schluessel[3] = 96;
  1646. X  }
  1647. X
  1648. X  if(UMLAUT_MODUS != INTEL_INSIDE){
  1649. X    USER.schluessel[3] = 96;
  1650. X  }
  1651. X
  1652. X  if(USER.schluessel[3] == 128)
  1653. X    sprintf(s, "[GRAPHICS:] %s", "yes");
  1654. X  else
  1655. X    sprintf(s, "[GRAPHICS:] %s", "no");
  1656. X  control(s, 3);
  1657. X
  1658. X  printf("%c", CR);
  1659. X}
  1660. X
  1661. END_OF_FILE
  1662.   if test 18265 -ne `wc -c <'mbox/src/intro.c'`; then
  1663.     echo shar: \"'mbox/src/intro.c'\" unpacked with wrong size!
  1664.   fi
  1665.   # end of 'mbox/src/intro.c'
  1666. fi
  1667. if test -f 'mbox/src/languages/francais.shh' -a "${1}" != "-c" ; then 
  1668.   echo shar: Will not clobber existing file \"'mbox/src/languages/francais.shh'\"
  1669. else
  1670.   echo shar: Extracting \"'mbox/src/languages/francais.shh'\" \(4754 characters\)
  1671.   sed "s/^X//" >'mbox/src/languages/francais.shh' <<'END_OF_FILE'
  1672. X?                   Affiche les commandes disponnibles
  1673. X? *                 Affiche toutes les commandes
  1674. Xcommand ?           Affiche l'aide qui concerne "command"
  1675. X
  1676. X0                   Liste vos macros commandes
  1677. X1-9                 Execute une de vos neuf macros
  1678. X
  1679. X+                   Va au prochain groupe avec des NOUVEAUX messages
  1680. X
  1681. X-                   Va au precedent groupe avec des NOUVEAUX messages
  1682. X
  1683. XACCOUNT             Creation de votre compte et boite aux lettres
  1684. X
  1685. XAREA +              Va a la section/groupe suivant(e)
  1686. XAREA ++             Va au groupe suivant
  1687. XAREA -              Va a la section/groupe precedent(e)
  1688. XAREA --             Va au groupe precedent
  1689. X
  1690. XBOARD               Affiche les sections qui ont des NOUVEAUX messages
  1691. XBOARD *             Affiche toutes les sections (depends de votre niveau)
  1692. XBOARD **            Affiche TOUTES les sections
  1693. XBOARD +             Va a la section suivante
  1694. XBOARD -             Va a la section precedente
  1695. XBOARD !             Affiche le nom de la section courante
  1696. XBOARD #             Liste les groupes contenus dans la section
  1697. XBOARD ..            Va au groupe precedent (dans la section)
  1698. XBOARD boardname     Va au groupe "boardname"
  1699. X
  1700. XCHAT                Discussion en ligne multi utilisateurs
  1701. X
  1702. XCOMBINE article artice
  1703. X
  1704. XDATE                Affiche la date courante
  1705. X
  1706. XDELETE 1            Detruit le message numero 1
  1707. XDELETE 8-12         Detruit les messages depuis 8 jusqu'a 12
  1708. XDELETE >            Detruit les copies de vos propres Emails dans votre BAL
  1709. X
  1710. XDIR                 Affiche l'index des NOUVEAUX messages
  1711. XDIR *               Affiche l'index de TOUS les messages (de la section)
  1712. X
  1713. XDIRECTION           Sens de la lecture VIEUX <-> NOUVEAUX ?
  1714. X
  1715. XDOWNLOAD            Recevoir des messages ASCII en utilisant le protocle
  1716. X                    de transfert de son choix
  1717. X
  1718. XEDIT 1              Editer le message numero 1
  1719. X
  1720. XFINGER user         Affiche les information qui concernent l'utilisateur
  1721. X
  1722. XFORWARD             Affiche la liste des Emails preserve's
  1723. XFORWARD user        Reposte un Email pour "user"
  1724. XFORWARD 1 user      Poste le message numero 1 en Email pour "user"
  1725. X
  1726. XGAMES               Affiche la liste des jeux
  1727. X
  1728. XGOODBYE             Quitte le bbs
  1729. X
  1730. XHELP                Affiche cette aide (resume')
  1731. XHELP *              display some pages of helpful descriptions
  1732. XHELP command        Affiche l'aide qui concerne la commande
  1733. X
  1734. XMAIL user             Envoie un Email a user
  1735. XMAIL host!user        Envoie un Email a user sur la machine host
  1736. XMAIL user@host.domain Envoie un Email a user sur la machine host.domain
  1737. X
  1738. XMACRO               Affiche/Modifie vos macros
  1739. X
  1740. XMESSAGE             Affiche/Modifie votre message d'acceuil
  1741. X
  1742. XMINIX OS-command    Execute une commande shell
  1743. X
  1744. XPORTINFO            Affiche qui fait quoi sur quel terminal
  1745. X
  1746. XPROTOCOL            Affiche les derniers appelants
  1747. XPROTOCOL *          Affiche une liste complete des appels sur le bbs
  1748. XPROTOCOL #          Statistiques des appels du bbs
  1749. XPROTOCOL %          Statitiques des utilisateurs (TOP 50)
  1750. X
  1751. XPM                  Va dans votre Boite Aux Lettres
  1752. X
  1753. XREAD                Lire les NOUVEAUX messages
  1754. XREAD *              Lire TOUS les messages d'une section
  1755. XREAD 1              Lire le message numero 1
  1756. XREAD 8-12           Lire depuis le message 8 jusqu'au 12
  1757. X
  1758. XROT13    
  1759. X
  1760. XSEARCH expression   Recherche l'expression dans tous les messages de la
  1761. X                    section courante
  1762. X
  1763. XSETUP               Configuration de vos preferences
  1764. X
  1765. XSIGNATURE           Affiche/Modifie la signature qui est ajoutee a la fin
  1766. X                    de tous les messages que vous ecrivez
  1767. X
  1768. XSTATE               Affiche votre configuration courante
  1769. X
  1770. XSTATISTICS          Statistiques sur les NEWS
  1771. XSTATISTICS *        Statistiques plus completes sur les NEWS
  1772. XSTATISTICS $        Vitesses UUCP (si UUCP garde ces renseignements)
  1773. XSTATISTICS #        Statistiques sur le telechargement
  1774. XSTATISTICS %        Statisitiques sur le telechargement (TOP 50)
  1775. XSTATISTICS >        Statistiques sur les Emails
  1776. X
  1777. XSUBSCRIBE
  1778. X
  1779. XTHREAD
  1780. XTHREAD 1            Suivre un sujet a travers les messages d'un groupe
  1781. X
  1782. XTIME                Affiche l'heure local et depuis combien de temps vous
  1783. X                    etes connecte'
  1784. X
  1785. XUSERS               Affiche la liste des utilisateurs
  1786. XUSERS *             Affiche une liste plus complete des utilisateurs
  1787. XUSERS #             Affiche le ratio envoi/telechargement
  1788. XUSERS %             Affiche les utilisateurs avec leurs groupes
  1789. XUSERS $             Information sur les comptes (payants ;-) )
  1790. XUSERS user          Affiche les informations sur user
  1791. X
  1792. XVERSION             Affiche le numero de version du bbs
  1793. XVERSION *           Affiche les informations de compilation du bbs
  1794. XVERSION #           Affiche le "Mur des vainqueurs"
  1795. X
  1796. XWRITE               Cree un nouveau message et le poste
  1797. END_OF_FILE
  1798.   if test 4754 -ne `wc -c <'mbox/src/languages/francais.shh'`; then
  1799.     echo shar: \"'mbox/src/languages/francais.shh'\" unpacked with wrong size!
  1800.   fi
  1801.   # end of 'mbox/src/languages/francais.shh'
  1802. fi
  1803. if test -f 'mbox/src/pd.c' -a "${1}" != "-c" ; then 
  1804.   echo shar: Will not clobber existing file \"'mbox/src/pd.c'\"
  1805. else
  1806.   echo shar: Extracting \"'mbox/src/pd.c'\" \(23193 characters\)
  1807.   sed "s/^X//" >'mbox/src/pd.c' <<'END_OF_FILE'
  1808. X/* ix/MBox (pd.c) by Volker Schuermann, 04.12.1993
  1809. X
  1810. X   This C source code contains the following functions:
  1811. X
  1812. X   #PD pd()              sending a file to user under protocol control
  1813. X   #ST status()          display users preferences
  1814. X   #MK mkix()            making a file unix-like
  1815. X   #SK statistik()       building statistics of the CALLS file
  1816. X   #AR archivieren()     pack&compress a couple of articles
  1817. X   #DL download()        do the downloading of a group of files
  1818. X   #AT alltime()         show "all calls ever"
  1819. X   #AU auslastung()     print the usage of the terminal ports
  1820. X
  1821. X   Contact <volkers@unnet.wupper.de> for help! */
  1822. X
  1823. X
  1824. X
  1825. X
  1826. X
  1827. X  
  1828. X#include <stdio.h>
  1829. X#include <sys/types.h>
  1830. X#include <signal.h>
  1831. X#include <sys/stat.h>
  1832. X#include <time.h>
  1833. X
  1834. X#include "mbox.h"
  1835. X
  1836. X
  1837. X
  1838. X
  1839. X/* #PD - A file [arg] is transfered under protocol (SZ, SB, SX) control.
  1840. X
  1841. X   [keywds] stands for Keywords. This header line should contain a 
  1842. X   few words describing the contents of the file. */
  1843. X
  1844. Xvoid pd(arg, keywds)
  1845. XUNSIGNED char arg[], keywds[];
  1846. X{
  1847. X  FILE *fp;
  1848. X  FILE *ff;
  1849. X
  1850. X  UNSIGNED char s[STRING];
  1851. X  UNSIGNED char tmp[STRING];
  1852. X  UNSIGNED char c;
  1853. X  UNSIGNED char protokoll;
  1854. X  UNSIGNED char cd[STRING];
  1855. X  struct stat fst;
  1856. X  long ts, tn;
  1857. X
  1858. X  int cps, bps, eff;
  1859. X  int ok, i;
  1860. X  int bytes = 0;
  1861. X
  1862. X  strcpy(cd, stripped(arg));
  1863. X
  1864. X  printf("\n\n");
  1865. X  ansi2("md", 0, 0);
  1866. X  printf("%s\n\n", PD01_MSG);
  1867. X  
  1868. X  if(keywds[0] != '\0'){
  1869. X    printf("%s ", PD02_MSG); 
  1870. X    ansi2("me", 0, 0);
  1871. X    printf("%s\n\n", keywds);
  1872. X  }
  1873. X  else{
  1874. X     ansi2("me", 0, 0);
  1875. X  }
  1876. X
  1877. X  ansi2("mr", 0, 0);
  1878. X  printf("%c%s [%c, %c, (%c)] >  ", CR, PD03_MSG, GBL06_MSG, GBL07_MSG, PD06_MSG);
  1879. X  ansi2("me", 0, 0);
  1880. X
  1881. X  do {
  1882. X    c = getint();
  1883. X    if (c >= 97) c -= 32;
  1884. X    if ((c != GBL06_MSG) && (c != GBL07_MSG) && (c != PD06_MSG)) c = 0;
  1885. X  } while (c == 0);
  1886. X
  1887. X  printf("%c", c);
  1888. X
  1889. X  if (c == PD06_MSG) {    /*  X  */
  1890. X    printf("\n");
  1891. X    sigcatch(SIGINT);    
  1892. X  }
  1893. X
  1894. X  if (c != GBL06_MSG) {    /*  J  */
  1895. X    printf("\n");
  1896. X    return;
  1897. X  }
  1898. X  ansi2("mr", 0, 0);
  1899. X  printf("%c[%s] %c, %c, %c, %c ? > ", CR, PD07_MSG, PD08_MSG, PD09_MSG, PD10_MSG, PD11_MSG);
  1900. X  ansi2("me", 0, 0);
  1901. X
  1902. X
  1903. X  do {
  1904. X    protokoll = getint();
  1905. X    if (protokoll >= 97) protokoll -= 32;
  1906. X    if (protokoll == '?') {
  1907. X        clearline();
  1908. X        ansi2("mr", 0, 0);
  1909. X        printf("%c%s > ", CR, PD12_MSG);
  1910. X        ansi2("me", 0, 0);
  1911. X    }
  1912. X    if ((protokoll != PD08_MSG) && (protokoll != PD09_MSG) &&
  1913. X        (protokoll != PD10_MSG) && (protokoll != PD11_MSG))
  1914. X        protokoll = 0;
  1915. X  } while (protokoll == 0);
  1916. X
  1917. X
  1918. X  printf("%c", protokoll);
  1919. X
  1920. X  printf("\n\n");
  1921. X  ansi2("md", 0, 0);
  1922. X  printf("%s\n\n", PD13_MSG);
  1923. X  ansi2("me", 0, 0);
  1924. X
  1925. X  time(&ts);
  1926. X
  1927. X  switch (protokoll) {
  1928. X      case PD08_MSG:
  1929. X        sprintf(s, "exec cat %s", cd);
  1930. X        break;
  1931. X      case PD09_MSG:
  1932. X        sprintf(s, "exec %s -b %s 2> /dev/null", SX, cd);
  1933. X        break;
  1934. X      case PD10_MSG:
  1935. X        sprintf(s, "exec %s %s 2> /dev/null", SB, cd);
  1936. X        break;
  1937. X      case PD11_MSG:
  1938. X        sprintf(s, "exec %s %s 2> /dev/null", SZ, cd);
  1939. X        break;
  1940. X  }
  1941. X  system( s );
  1942. X
  1943. X  time(&tn); tn = tn - ts; 
  1944. X
  1945. X  /*
  1946. X  stat(cd, &fst);
  1947. X  USER.downratio += ((long) fst.st_size / 1024);
  1948. X  */
  1949. X  sprintf(tmp, "%s/dnl.%d", TMP, getpid());
  1950. X  sprintf(s, "wc -c %s > %s", cd, tmp);
  1951. X  system( s ); 
  1952. X  fp = fopen( tmp, "r" );
  1953. X  if(fp == NULL){
  1954. X    nerror("pd.c", 154, "pd", "Can't read from", tmp);    
  1955. X  }
  1956. X  while(fgets(s, STRING, fp) != 0) bytes += atoi(s);
  1957. X  fclose(fp); 
  1958. X  unlink( tmp );
  1959. X
  1960. X  ansi2( "md", 0, 0 );
  1961. X  if(tn < 1) tn = 1;
  1962. X  /*
  1963. X  cps = fst.st_size / tn;
  1964. X  */
  1965. X  cps = bytes / tn;
  1966. X  bps = cps * 11;
  1967. X
  1968. X  BAUDRATE = baudrate( bps );
  1969. X
  1970. X  eff = ((100000 / BAUDRATE) * bps) / 1000;  
  1971. X
  1972. X  if(bps > BAUDRATE){
  1973. X    printf("\n\n%s\n", PD14_MSG);
  1974. X    ok = -1;
  1975. X  }
  1976. X  else{
  1977. X    /*    
  1978. X    printf("\n\n%ld %s.\n", fst.st_size, PD15_MSG);
  1979. X    */
  1980. X    printf("\n\n%d %s.\n", bytes, PD15_MSG);
  1981. X    ok = 0;
  1982. X  }
  1983. X
  1984. X  ansi2( "me", 0, 0 );
  1985. X  printf("%s %d cps (ca. %d bps).", PD16_MSG, cps, bps);
  1986. X  sprintf(tmp, "%s/%d.pd", TMP, getpid());
  1987. X  ff = fopen( tmp, "w" );
  1988. X
  1989. X
  1990. X  if(ok == 0){
  1991. X    fprintf(ff, "%s  %c  %-40.40s", mydate( 1 ), protokoll, cd); 
  1992. X    if((bps < BAUDRATE) && (bps > 0)){
  1993. X        fprintf(ff, "  %6d  %6d  %2d%% OK\n", cps, bps, eff);
  1994. X    }
  1995. X    else{
  1996. X        fprintf(ff, "  %6d  %6d  %2d%% BRK\n", cps, bps, eff);
  1997. X    }
  1998. X  }
  1999. X
  2000. X  i = 0;
  2001. X
  2002. X  fp = fopen( PDLOG, "r" );
  2003. X  if(fp != NULL){
  2004. X    while((fgets(s, STRING, fp) != NULL) && (i < PRO_ENTRIES)){
  2005. X        fputs(s, ff);
  2006. X        i++;
  2007. X    }
  2008. X    fclose(fp);
  2009. X  }
  2010. X
  2011. X  fclose(ff);
  2012. X
  2013. X  sprintf(cd, "mv %s %s", tmp, PDLOG);
  2014. X  system( cd );
  2015. X
  2016. X  printf("\n");
  2017. X}
  2018. X
  2019. X
  2020. X
  2021. X
  2022. X
  2023. X
  2024. X/* #ST - Show users preferences. */
  2025. X
  2026. Xvoid status()
  2027. X{
  2028. X  UNSIGNED char s[STRING];
  2029. X  UNSIGNED char t[STRING];
  2030. X  UNSIGNED char d[STRING];
  2031. X  UNSIGNED char ex[255];
  2032. X  int a, b;
  2033. X  int i;
  2034. X
  2035. X
  2036. X  sprintf(s, " %s %d) %s ", PD18_MSG, USER.id, USER.name);
  2037. X  headline(s);
  2038. X  printf("\n");
  2039. X
  2040. X  ansi2("md", 0, 0);
  2041. X  printf("%s", PD19_MSG);
  2042. X  ansi2("me", 0, 0);
  2043. X
  2044. X  printf("\n");
  2045. X
  2046. X  sprintf(ex, "%s                                        ", USER.name);
  2047. X  ex[27] = '\0';
  2048. X  strcat(ex, USER.nick);
  2049. X  strcat(ex, "                            ");
  2050. X  ex[45] = '\0';
  2051. X  strcat(ex, USER.geburtsdatum);
  2052. X  strcat(ex, "                            ");
  2053. X  ex[62] = '\0';
  2054. X  strcat(ex, USER.telefon1);
  2055. X  printf("%s\n", ex);
  2056. X
  2057. X  sprintf(ex, "%s                                        ", USER.strasse);
  2058. X  ex[27] = '\0';
  2059. X  strcat(ex, USER.sh_name);
  2060. X  strcat(ex, "                            ");
  2061. X  ex[45] = '\0';
  2062. X  strcat(ex, "                            ");
  2063. X  ex[62] = '\0';
  2064. X  strcat(ex, USER.telefon2);
  2065. X  printf("%s\n", ex);
  2066. X
  2067. X  printf("%s\n\n", USER.wohnort);
  2068. X  ansi2("md", 0, 0);
  2069. X  printf("%s", PD20_MSG);  
  2070. X  ansi2("me", 0, 0);
  2071. X  printf("\n");
  2072. X
  2073. X  s[0] = '\0'; strcat(s, datereconv( LASTLOG ));
  2074. X  strcat(s, "-"); strcat(s, timereconv( LASTTIME ));
  2075. X  s[16] = '\0';
  2076. X
  2077. X  sprintf(ex, "       %1d       %1d  %5d     %1d       %1d     %1d      %1d  %6d  %s",
  2078. X    USER.terminal, USER.editor, USER.level, USER.bell, USER.prompt, USER.more, USER.intro, USER.seq, s);
  2079. X  printf("%s\n\n", ex);
  2080. X
  2081. X  ansi2("md", 0, 0);
  2082. X  printf("%s", PD21_MSG);  
  2083. X  ansi2("me", 0, 0);
  2084. X  sprintf(ex, "\n%06.6d                      %06.6d                    %06.6d",
  2085. X    (USER.elapsed / 60), USER.upratio, USER.downratio);
  2086. X  printf("%s\n\n", ex);
  2087. X
  2088. X  ansi2("md", 0, 0);
  2089. X  printf("%s", PD22_MSG);
  2090. X  ansi2("me", 0, 0);
  2091. X
  2092. X  i = 0;
  2093. X  strcpy(s, (UNSIGNED char *) USER.name);
  2094. X  while (s[i] != '\0') {
  2095. X    if (s[i] == ' ') s[i] = '.';
  2096. X    i++;
  2097. X  }
  2098. X
  2099. X  sprintf(t,  "%s: %s@%s", PD23_MSG, s, UUCPID);
  2100. X  strcpy(d, USER.account); d[10] = '\0';
  2101. X  strcpy(s, (UNSIGNED char *) strcopy(USER.account, 11, 16));
  2102. X  i = atoi(s); 
  2103. X  sprintf(s, "%s  %3d.%02d", d, fix(i), flt(i));
  2104. X  sprintf(ex, "%-54.54s%s DM\n%s: %s%s", t, s, PD24_MSG, UUCPBANG, USER.nick);
  2105. X  printf("\n%s\n", ex);
  2106. X  if (USER.sh_name[0] != '\0')
  2107. X    printf("%s: %s!%s\n", PD25_MSG, UUCPSITE, USER.sh_name);
  2108. X
  2109. X  printf("\n");
  2110. X
  2111. X  ansi2("md", 0, 0);
  2112. X  printf("%s\n", PD26_MSG);
  2113. X
  2114. X  ansi2("me", 0, 0);
  2115. X
  2116. X  i = 1;
  2117. X  while(newsgrp[i][0] != '\0'){
  2118. X    if(i != 1) printf(", ");
  2119. X    printf("%s", newsgrp[i]);
  2120. X    i++;
  2121. X  }
  2122. X
  2123. X  printf("\n\n");  
  2124. X}
  2125. X
  2126. X
  2127. X
  2128. X
  2129. X
  2130. X/* #MX - Converting a file [s] to unix format (i.e. deleting CRs). 
  2131. X
  2132. X   This function doesn't return anything. The file [s] itself is changed. */
  2133. X
  2134. Xvoid mkix( pfad )
  2135. XUNSIGNED char pfad[];
  2136. X{
  2137. X  FILE *fp; 
  2138. X  FILE *ff;
  2139. X
  2140. X  UNSIGNED char s[LONGSTRING];
  2141. X  UNSIGNED char p[LONGSTRING];
  2142. X
  2143. X  int i, ok = 0;
  2144. X
  2145. X  
  2146. X  sprintf(p, "%sabc", pfad);
  2147. X
  2148. X  fp = fopen( pfad, "r" );
  2149. X  if(fp == NULL){
  2150. X    return;
  2151. X  }      
  2152. X
  2153. X  ff = fopen( p, "w" );
  2154. X  if(ff == NULL){
  2155. X    nerror("pd.c", 243, "mkix", "Can't write to", p);    
  2156. X  }
  2157. X
  2158. X  while((ok == 0) && (fgets(s, LONGSTRING, fp) != NULL)){
  2159. X    i = 0;
  2160. X    while(s[i] != '\0'){
  2161. X        if(s[i] == CTRL_Z){
  2162. X            ok++;
  2163. X            break;
  2164. X        }
  2165. X        i++;
  2166. X    }
  2167. X    if(ok == 0){
  2168. X        i = strlen(s) -2;
  2169. X        if(s[i] == CR){
  2170. X            s[i]    = LF;
  2171. X            s[i +1] = '\0';
  2172. X        }
  2173. X        fputs(s, ff);
  2174. X    }
  2175. X  }
  2176. X  fclose(fp);
  2177. X  fclose(ff);
  2178. X
  2179. X  unlink(pfad);
  2180. X  mbrename(p, pfad);
  2181. X}
  2182. X
  2183. X
  2184. X
  2185. X
  2186. X
  2187. X/* #SK - Develope a graphical statistic from the CALLS file. */
  2188. X
  2189. Xvoid statistik()
  2190. X{
  2191. X  FILE *fp;
  2192. X
  2193. X  struct tm *tp;
  2194. X  time_t tt;
  2195. X
  2196. X  UNSIGNED char s[STRING];
  2197. X  UNSIGNED char od[MAX_TAGE][STRING];
  2198. X  UNSIGNED char t[STRING];
  2199. X  UNSIGNED char r[STRING];
  2200. X
  2201. X  UNSIGNED char ex[LONGSTRING];
  2202. X
  2203. X  int v18u[MAX_TAGE];
  2204. X  int n18u[MAX_TAGE];
  2205. X  int v18g = 0;
  2206. X  int n18g = 0;
  2207. X
  2208. X  int zeit = 0;
  2209. X  int tage = 0;
  2210. X  int max  = 0;
  2211. X
  2212. X  int i, a;
  2213. X  int toggle = 0;
  2214. X  int sonntag;
  2215. X
  2216. X  int sdep = 7;
  2217. X
  2218. X
  2219. X  if(USER.terminal == ISO6429) sdep -= 3;
  2220. X
  2221. X  fp = fopen( CALLS, "r" );
  2222. X  if(fp == NULL){
  2223. X    nerror("pd.c", 288, "statistik", "Can't read", CALLS);        
  2224. X  }
  2225. X
  2226. X  od[0][0] = '\0';
  2227. X
  2228. X  headblock( PD27_MSG, PD28_MSG );
  2229. X
  2230. X  while((fgets(s, (STRING *2), fp) != NULL) && (tage < (MAX_SCR_LINES -sdep))){
  2231. X    strcpy(t, (UNSIGNED char *) strcopy(s, 64, 71));
  2232. X
  2233. X    if(strcomp(t, od[tage]) != 0){
  2234. X        if(tage != 0){
  2235. X            if((v18u[tage] + n18u[tage]) > max){
  2236. X                max = v18u[tage] + n18u[tage];
  2237. X            }
  2238. X            v18g += v18u[tage];
  2239. X            n18g += n18u[tage];
  2240. X        }
  2241. X        tage++;
  2242. X        od[tage][0] = '\0'; strcat(od[tage], t);
  2243. X        v18u[tage] = 0;
  2244. X        n18u[tage] = 0;
  2245. X        }
  2246. X    zeit = atoi(strcopy(s, 74, 75));
  2247. X    if((zeit >   6) && (zeit < 18)) v18u[tage]++;
  2248. X    if((zeit >= 18) || (zeit <= 6)) n18u[tage]++;
  2249. X  }
  2250. X
  2251. X  sprintf(s, "%s", "ooooooooooooooooooooooooooooooooooooooooooooooooooooo");
  2252. X
  2253. X  time(&tt);
  2254. X  tp = localtime(&tt);
  2255. X  sonntag = tp->tm_wday;
  2256. X
  2257. X  for(i = 1; i < tage; i++){
  2258. X    sprintf(t, "%s", s);
  2259. X    a = (290 / max * (v18u[i] + n18u[i])) / 10;
  2260. X    t[a] = '\0';    
  2261. X    strcpy(r, "    ");    
  2262. X    if(sonntag == 0){
  2263. X        strcpy(r, PD29_MSG);
  2264. X        toggle++;    
  2265. X        ansi2( "md", 0, 0 );
  2266. X    }
  2267. X    if(sonntag == 6) 
  2268. X        strcpy(r, PD30_MSG);
  2269. X    sonntag--;
  2270. X    if(sonntag == -1) sonntag = 6;
  2271. X
  2272. X    printf("%s %s %4d        %5d         %5d      %s\n",
  2273. X                od[i], r, v18u[i], n18u[i], v18u[i]+n18u[i], t);
  2274. X    if(toggle != 0) ansi2( "me", 0, 0 );
  2275. X    toggle = 0;
  2276. X  }
  2277. X
  2278. X  if(USER.terminal != ISO6429){
  2279. X    printf("-------------------------------------------------------------------------------\n");
  2280. X    if((tage-1) > 0){
  2281. X        printf("%s %5d        %5d         %5d      %s (%d %s)\n",
  2282. X            PD31_MSG, v18g, n18g, v18g+n18g, PD32_MSG, (v18g+n18g)/(tage-1), PD32aMSG);
  2283. X    }
  2284. X    else{
  2285. X        printf("%s %5d        %5d         %5d      %s\n",
  2286. X            PD31_MSG, v18g, n18g, v18g+n18g, PD32_MSG);
  2287. X    }
  2288. X    printf("===============================================================================\n");
  2289. X  }
  2290. X  else{
  2291. X    if((tage-1) > 0){
  2292. X        sprintf(ex, (UNSIGNED char *) "%s %5d        %5d         %5d      %s (%d %s)",
  2293. X            PD31_MSG, v18g, n18g, v18g+n18g, PD32_MSG, (v18g+n18g)/(tage-1), PD32aMSG);
  2294. X    }
  2295. X    else{
  2296. X        sprintf(ex, (UNSIGNED char *) "%s %5d        %5d         %5d      %s",
  2297. X            PD31_MSG, v18g, n18g, v18g+n18g, PD32_MSG);
  2298. X    }
  2299. X    ansi2( "X1", 0, 0 );    
  2300. X    strcat(ex, (UNSIGNED char *) "                                                                            ");
  2301. X    ex[79] = '\0';
  2302. X    printf("%s\n", ex); 
  2303. X    ansi2( "me", 0, 0 );
  2304. X  }
  2305. X
  2306. X  printf("\n%s %d %s.\n", PD33_MSG, (tage -1), PD34_MSG);   
  2307. X
  2308. X  fclose(fp);
  2309. X}
  2310. X
  2311. X
  2312. X
  2313. X
  2314. X
  2315. X
  2316. X
  2317. X/* #AR - Select a packer / compresser and treat a list of articles [arg].
  2318. X
  2319. X   This function returns the name/path of the new "package". */
  2320. X
  2321. XUNSIGNED char *archivieren( arg )
  2322. XUNSIGNED char arg[];
  2323. X{
  2324. X  FILE *fp;
  2325. X  int i, c;
  2326. X
  2327. X  struct stat fstat;
  2328. X
  2329. X  UNSIGNED char s[LONGSTRING+STRING];
  2330. X  UNSIGNED char t[STRING];
  2331. X  UNSIGNED char packers[10][STRING];
  2332. X  UNSIGNED char adds[10][STRING];
  2333. X  UNSIGNED char tar[10][STRING];
  2334. X  UNSIGNED char en[10][STRING];
  2335. X  UNSIGNED char cd[LONGSTRING];
  2336. X
  2337. X  int fpid;
  2338. X
  2339. X
  2340. X  headline( PD37_MSG );
  2341. X  printf("\n");
  2342. X
  2343. X  sprintf(s, "%s/%s", HOME, PACKERS);
  2344. X  fp = fopen(s, "r");
  2345. X  if (fp == NULL) {
  2346. X    nerror("pd.c", 495, "archivieren", "Can't read", s);
  2347. X  }
  2348. X
  2349. X  printf("  1 - Text/ASCII\n\n");
  2350. X  strcpy(packers[1], (UNSIGNED char *) "cat");
  2351. X  strcpy(adds[1], (UNSIGNED char *) "?");
  2352. X  strcpy(tar[1], (UNSIGNED char *) "-");
  2353. X  en[1][0] = '\0';
  2354. X  i = 1;
  2355. X  while((fgets(s, 80, fp) != NULL) && (s[0] != '='));
  2356. X  while((i < 10) && (fscanf(fp, "%s %s %s %s %s", s, packers[i], adds[i], tar[i], en[i]) > 0)){
  2357. X    i++;
  2358. X    printf("  %d - %s\n\n", i, s); 
  2359. X  }
  2360. X  fclose(fp);
  2361. X
  2362. X  ansi2("md", 0, 0);
  2363. X  printf("\n%s > ", PD38_MSG);
  2364. X  ansi2("me", 0, 0);
  2365. X
  2366. X  c = getint();
  2367. X  if(c > 32) printf("%c", c);
  2368. X  c -= 49;
  2369. X
  2370. X  if((c > i) || (c < 0)) return (UNSIGNED char *) "Noe!";
  2371. X
  2372. X  
  2373. X  printf("\n\n%s .", PD39_MSG);
  2374. X
  2375. X  switch( (fpid = fork()) ){
  2376. X    case -1 :
  2377. X        break;
  2378. X    case  0 : 
  2379. X        while(1){
  2380. X            printf(".");
  2381. X            sleep(2);
  2382. X        }    
  2383. X        break;
  2384. X  }
  2385. X
  2386. X  strcpy(cd, (UNSIGNED char *) arg);
  2387. X
  2388. X
  2389. X  if(c != 0){
  2390. X
  2391. X    if(tar[c][0] != '-'){
  2392. X        sprintf(t, "%s.tar", mytime(0));
  2393. X        t[5] = '-';
  2394. X        t[2] = '-';
  2395. X        sprintf(s, "exec %s %s %s > /dev/null 2>&1", TAR, t, cd);
  2396. X        system( s );
  2397. X        strcpy(cd, (UNSIGNED char *) t);
  2398. X    }    
  2399. X    else{
  2400. X        sprintf(t, "%s", mytime(0));
  2401. X        t[5] = '-';
  2402. X        t[2] = '-';
  2403. X    }
  2404. X
  2405. X    if(adds[c][0] == '?')
  2406. X        sprintf(s, "exec %s %s > /dev/null 2>&1", packers[c], cd);
  2407. X    else
  2408. X        sprintf(s, "exec %s %s %s %s > /dev/null 2>&1", packers[c], adds[c], t, cd);
  2409. X    
  2410. X    system( s );
  2411. X
  2412. X    unlink( t );
  2413. X
  2414. X    strcat(t, (UNSIGNED char *) en[c]);
  2415. X
  2416. X  }
  2417. X  else{        /* Text/ASCII */
  2418. X    
  2419. X    sprintf(t, "%s", mytime(0));
  2420. X    t[5] = '-';    
  2421. X    t[2] = '-';
  2422. X
  2423. X    sprintf(s, "exec %s %s > %s", packers[c], cd, t);
  2424. X
  2425. X    system( s );
  2426. X  }
  2427. X
  2428. X  kill( fpid, SIGKILL );
  2429. X  (void) wait( &fpid );
  2430. X
  2431. X  clearline();
  2432. X
  2433. X  if(tar[c][0] != '-'){
  2434. X    ansi2( "md", 0, 0 );
  2435. X    printf( PD40_MSG );
  2436. X    ansi2( "me", 0, 0 );
  2437. X    printf("%s\n", PD41_MSG);
  2438. X  }  
  2439. X
  2440. X  stat(t, &fstat);
  2441. X  printf("%s \"%s\" %s %ld %s.", PD42_MSG, t, PD43_MSG, fstat.st_size, PD44_MSG);
  2442. X
  2443. X
  2444. X  return (UNSIGNED char *) t;
  2445. X}
  2446. X
  2447. X
  2448. X
  2449. X
  2450. X
  2451. X
  2452. X/* #DL - Transfer one or a couple of article(s) [arg] to a user. */
  2453. X
  2454. X#define MAX_DL_FILES 50
  2455. X
  2456. Xvoid download( arg )
  2457. XUNSIGNED char arg[];
  2458. X{
  2459. X  int i, k, l, m;
  2460. X  int von, bis;
  2461. X  int ALLE;
  2462. X  int protokoll, ok;
  2463. X  int cps, bps, eff;
  2464. X
  2465. X  long ts, tn;
  2466. X  long bytes_total = 0L;
  2467. X
  2468. X  struct stat fst;
  2469. X
  2470. X  UNSIGNED char s[STRING];
  2471. X  UNSIGNED char cd[LONGSTRING];
  2472. X  UNSIGNED char t[(LONGSTRING+STRING)];
  2473. X  UNSIGNED char tmp[STRING];
  2474. X
  2475. X  UNSIGNED char files[MAX_DL_FILES][STRING];
  2476. X  int mdlp = 1;
  2477. X
  2478. X  int art[MAX_PER_NG];
  2479. X  int artp = 0;
  2480. X  int lastart;
  2481. X
  2482. X  int havetokill = 0;
  2483. X
  2484. X
  2485. X  FILE *fp, *ff;
  2486. X
  2487. X
  2488. X  if(arg[0] == '\0'){
  2489. X    ansi( "md" );
  2490. X    printf(" <- %s\n", PD35_MSG);
  2491. X    ansi( "me" );
  2492. X    return;
  2493. X  }
  2494. X  
  2495. X  tmp[0] = '\0';
  2496. X
  2497. X  i = 0;
  2498. X  k = -1;
  2499. X  l = -1;
  2500. X  m = -1;
  2501. X
  2502. X  while (arg[i] != '\0') {
  2503. X    if (arg[i] == '-') k = i;
  2504. X    if (arg[i] == '*') l = i;
  2505. X    if ((arg[i] > 48) && (arg[i] < 58) && (m == -1)) m = i;
  2506. X    i++;
  2507. X  }
  2508. X
  2509. X  von = 1;
  2510. X  bis = 32000;
  2511. X
  2512. X  if ((m == -1) && (l == -1) && (k == -1)) {
  2513. X    ansi2( "md", 0, 0 );
  2514. X    if(atoi(arg) != 0)
  2515. X        printf(" %s\n", PD44aMSG);
  2516. X    else
  2517. X        printf(" %s\n", PD44bMSG);
  2518. X    ansi2( "me", 0, 0 );
  2519. X    return;
  2520. X  }
  2521. X
  2522. X  if ((m != -1) && (l == -1) && (k == -1)) {
  2523. X    strcpy(s, (UNSIGNED char *) strcopy(arg, m, strlen(arg)));
  2524. X    von = atoi(s);
  2525. X    bis = von;
  2526. X  }
  2527. X  if (k != -1) {
  2528. X    strcpy(s, (UNSIGNED char *) strcopy(arg, 0, (k - 1)));
  2529. X    von = atoi(s);
  2530. X    strcpy(s, (UNSIGNED char *) strcopy(arg, (k + 1), strlen(arg)));
  2531. X    bis = atoi(s);
  2532. X
  2533. X    if (von == 0) von = 1;
  2534. X    if (bis == 0) bis = 32000;
  2535. X  }
  2536. X  
  2537. X  if(von > bis){
  2538. X    i = bis;
  2539. X    bis = von;
  2540. X    von = i;
  2541. X  }
  2542. X
  2543. X  maybe_locked(INHALT, "r");
  2544. X  fp = fopen(INHALT, "r");
  2545. X  if (fp == NULL) {
  2546. X    nerror("pd.c", 504, "download", "Can't read", INHALT);
  2547. X  }
  2548. X  while (fgets(cd, LONGSTRING, fp) != NULL){
  2549. X    i = atoi(cd);
  2550. X    if((i >= von) && (i <= bis)){
  2551. X        art[artp] = i;
  2552. X        artp++;
  2553. X        if(artp > MAX_PER_NG){
  2554. X            printf("This is a known bug ;-)");
  2555. X            exit(0);
  2556. X        }        
  2557. X    }
  2558. X  }
  2559. X  fclose(fp);
  2560. X
  2561. X
  2562. X  printf("\n\n");
  2563. X
  2564. X  ansi2("mr", 0, 0);
  2565. X  printf("%c[%s] %c, %c, %c, %c ? > ", CR, PD07_MSG, PD08_MSG, PD09_MSG, PD10_MSG, PD11_MSG);
  2566. X  ansi2("me", 0, 0);
  2567. X
  2568. X
  2569. X  do {
  2570. X    protokoll = getint();
  2571. X    if (protokoll >= 97) protokoll -= 32;
  2572. X    if (protokoll == '?') {
  2573. X        clearline();
  2574. X        ansi2("mr", 0, 0);
  2575. X        printf("%c%s > ", CR, PD12_MSG);
  2576. X        ansi2("me", 0, 0);
  2577. X    }
  2578. X    if ((protokoll != PD08_MSG) && (protokoll != PD09_MSG) &&
  2579. X        (protokoll != PD10_MSG) && (protokoll != PD11_MSG))
  2580. X        protokoll = 0;
  2581. X  } while (protokoll == 0);
  2582. X
  2583. X
  2584. X  printf("%c", protokoll);
  2585. X
  2586. X
  2587. X  if (strcomp(CDROMNG, NG) != 0) {
  2588. X
  2589. X    if (strcomp(BRETT, "PM") != 0) {
  2590. X               sprintf(s, "%s", BRETT); 
  2591. X    }
  2592. X    else {
  2593. X        sprintf(s, "%s/usr/%c/%d", HOME, USER.name[0], USER.id);
  2594. X    }
  2595. X    chdir( s );
  2596. X    
  2597. X    cd[0] = '\0';
  2598. X    printf("\n\n%s .", PD36_MSG);
  2599. X
  2600. X    lastart = artp;
  2601. X
  2602. X    for( i = 0; i < artp; i++){  
  2603. X
  2604. X        sprintf(s, "%d", art[i]); 
  2605. X    
  2606. X        fp = fopen(s, "r");
  2607. X        if(fp != 0){
  2608. X            printf(".");
  2609. X
  2610. X            while ((fgets(t, LONGSTRING, fp) != NULL) && (t[0] > 32));
  2611. X            while ((fgets(t, LONGSTRING, fp) != NULL) && (t[0] < 32));
  2612. X
  2613. X            ok = 0;
  2614. X
  2615. X            if (strcomp("BINFILE", t) == 0) {
  2616. X                fgets(t, STRING, fp);
  2617. X                strcpy(s, (UNSIGNED char *) stripped(t));
  2618. X                ok++;
  2619. X            }
  2620. X            if(((2 + strlen(s) + strlen(cd)) < LONGSTRING) && (mdlp < MAX_DL_FILES)){
  2621. X                stat(s, &fst);
  2622. X                bytes_total += (long) fst.st_size;
  2623. X
  2624. X                if(ok != 0){
  2625. X                    strcpy(files[mdlp], s);
  2626. X                    mdlp++;                
  2627. X                    USER.downratio += ((long) fst.st_size / 1024);
  2628. X                }
  2629. X    
  2630. X                strcat(cd, s); 
  2631. X                strcat(cd, " ");
  2632. X                lastart = i;
  2633. X            }
  2634. X            fclose(fp);
  2635. X        }
  2636. X    }
  2637. X  }
  2638. X  else{            /* Download from CDROM */
  2639. X    
  2640. X    chdir( BRETT );
  2641. X    
  2642. X    cd[0] = '\0';
  2643. X    printf("\n\n%s .", PD36_MSG);
  2644. X
  2645. X    lastart = artp;
  2646. X
  2647. X       fp = fopen( INHALT, "r" );      
  2648. X    fgets(s, STRING, fp);
  2649. X    fgets(s, STRING, fp);
  2650. X
  2651. X    for( i = 0; i < artp; i++){  
  2652. X
  2653. X        rewind( fp );    
  2654. X        printf(".");
  2655. X
  2656. X        while((fgets(s, STRING, fp) != 0) && (art[i] != atoi(s)));
  2657. X
  2658. X        l = 6;
  2659. X        while((s[l] != ' ') && (s[l] != '\0')) l++;    
  2660. X        strcpy(s, (UNSIGNED char *) strcopy(s, 6, (l - 1)));
  2661. X
  2662. X        if(((2 + strlen(s) + strlen(cd)) < LONGSTRING) && (mdlp < MAX_DL_FILES)){
  2663. X            stat(s, &fst);
  2664. X
  2665. X            bytes_total += (long) fst.st_size;
  2666. X
  2667. X            sprintf(files[mdlp], "%s/%s", BRETT, s);
  2668. X            mdlp++;                
  2669. X            USER.downratio += ((long) fst.st_size / 1024);
  2670. X    
  2671. X            strcat(cd, s); 
  2672. X            strcat(cd, " ");
  2673. X            lastart = i;
  2674. X        }
  2675. X    }
  2676. X    fclose(fp);
  2677. X  }    
  2678. X
  2679. X  if(cd[0] == '\0'){
  2680. X    ansi2("md", 0, 0);
  2681. X    printf("%c%s\n", CR, PD35_MSG);
  2682. X    ansi2("me", 0, 0);
  2683. X    chdir( HOME );
  2684. X    return;
  2685. X  }
  2686. X
  2687. X  if((protokoll != PD08_MSG) && (strcomp(PDNG, NG) != 0) && (strcomp("cdrom", NG) != 0)){
  2688. X    strcpy(s, (UNSIGNED char *) archivieren( cd ));
  2689. X    if(strcomp("Noe!", s) != 0){
  2690. X        strcpy(cd, (UNSIGNED char *) s);
  2691. X        havetokill++;
  2692. X    }
  2693. X  }
  2694. X  
  2695. X  printf("\n\n");
  2696. X  ansi2("md", 0, 0);
  2697. X  printf("%s\n\n", PD13_MSG);
  2698. X  ansi2("me", 0, 0);
  2699. X
  2700. X  time(&ts);
  2701. X
  2702. X  switch (protokoll) {
  2703. X      case PD08_MSG:
  2704. X        sprintf(t, "exec cat %s", cd);
  2705. X        break;
  2706. X      case PD09_MSG:
  2707. X        sprintf(t, "exec %s -b %s 2> /dev/null", SX, cd);
  2708. X        break;
  2709. X      case PD10_MSG:
  2710. X        sprintf(t, "exec %s %s 2> /dev/null", SB, cd);
  2711. X        break;
  2712. X      case PD11_MSG:
  2713. X        sprintf(t, "exec %s %s 2> /dev/null", SZ, cd);
  2714. X        break;
  2715. X  }    
  2716. X  system( t );
  2717. X
  2718. X  if(havetokill != 0) unlink( cd );
  2719. X
  2720. X  time(&tn); tn = tn - ts; 
  2721. X
  2722. X  chdir( HOME );
  2723. X
  2724. X  ansi2( "md", 0, 0 );
  2725. X  if(tn < 1) tn = 1;
  2726. X  cps = bytes_total / tn;
  2727. X  bps = cps * 11;
  2728. X
  2729. X  BAUDRATE = baudrate( bps );
  2730. X
  2731. X  eff = ((100000 / BAUDRATE) * bps) / 1000;
  2732. X
  2733. X  if((bps > BAUDRATE) || (bps < 1)){
  2734. X    printf("\n\n%s\n", PD14_MSG);
  2735. X    ok = -1;
  2736. X  }
  2737. X  else{    
  2738. X    printf("\n\n%ld %s.\n", fst.st_size, PD15_MSG);
  2739. X    ok = 0;
  2740. X  }
  2741. X
  2742. X  ansi2( "me", 0, 0 );
  2743. X  printf("%s %d cps (ca. %d bps).", PD16_MSG, cps, bps);  
  2744. X  
  2745. X  if(ok != -1){
  2746. X      
  2747. X    sprintf(tmp, "%s/%d.pd", TMP, getpid());
  2748. X    ff = fopen( tmp, "w" );
  2749. X
  2750. X    for(i = 1; i < mdlp; i++){
  2751. X        fprintf(ff, "%s  %c  %-40.40s", mydate( 1 ), protokoll, files[i]); 
  2752. X        fprintf(ff, "  %6d  %6d  %2d%% DNL\n", cps, bps, eff);        
  2753. X    }  
  2754. X
  2755. X    i = 0;
  2756. X
  2757. X    fp = fopen( PDLOG, "r" );
  2758. X    if(fp != NULL){
  2759. X        while((fgets(s, STRING, fp) != NULL) && (i < (PRO_ENTRIES * 4))){
  2760. X            fputs(s, ff);
  2761. X            i++;
  2762. X        }
  2763. X        fclose(fp);
  2764. X    }
  2765. X
  2766. X    fclose(ff);
  2767. X
  2768. X    sprintf(cd, "mv %s %s", tmp, PDLOG);
  2769. X    system( cd );
  2770. X  }
  2771. X  else{
  2772. X    if(ff != 0) fclose(ff);
  2773. X    if(tmp[0] != '\0') unlink(tmp);
  2774. X  }
  2775. X
  2776. X  if(lastart != (artp-1)){
  2777. X    ansi2( "md", 0, 0 );
  2778. X    printf("\n%s", PD40_MSG);
  2779. X    ansi2( "me", 0, 0 );
  2780. X    printf("%s %d %s %d %s!", PD45_MSG, art[0], PD46_MSG, art[lastart], PD47_MSG);
  2781. X  }
  2782. X
  2783. X  printf("\n\n");
  2784. X}
  2785. X
  2786. X
  2787. X
  2788. X/* #AT - Make up a statistic out of CALLS and ALLTIME files. */
  2789. X
  2790. Xvoid alltime()
  2791. X{
  2792. X  FILE *fp;
  2793. X  FILE *ff;
  2794. X
  2795. X  UNSIGNED char s[STRING];
  2796. X  UNSIGNED char z[STRING];
  2797. X  UNSIGNED char t[STRING];
  2798. X  UNSIGNED char m[STRING];
  2799. X  UNSIGNED char o[STRING];
  2800. X
  2801. X  UNSIGNED char monat[13][STRING];
  2802. X
  2803. X  int fpid;
  2804. X  int maxval = 0;
  2805. X  int i, a;
  2806. X  int toggle = 0;
  2807. X
  2808. X  strcpy(monat[ 1], PD51_MSG);
  2809. X  strcpy(monat[ 2], PD52_MSG);
  2810. X  strcpy(monat[ 3], PD53_MSG);
  2811. X  strcpy(monat[ 4], PD54_MSG);
  2812. X  strcpy(monat[ 5], PD55_MSG);
  2813. X  strcpy(monat[ 6], PD56_MSG);
  2814. X  strcpy(monat[ 7], PD57_MSG);
  2815. X  strcpy(monat[ 8], PD58_MSG);
  2816. X  strcpy(monat[ 9], PD59_MSG);
  2817. X  strcpy(monat[10], PD60_MSG);
  2818. X  strcpy(monat[11], PD61_MSG);
  2819. X  strcpy(monat[12], PD62_MSG);
  2820. X
  2821. X
  2822. X  sprintf(t, "%s/all.%d", TMP, getpid() );
  2823. X  sprintf(m, "%s/al2.%d", TMP, getpid() );
  2824. X
  2825. X  headblock( PD48_MSG, PD49_MSG );
  2826. X  printf("%s ..", PD50_MSG);
  2827. X    
  2828. X  switch( (fpid = fork()) ){
  2829. X    case -1 :
  2830. X        break;
  2831. X    case  0 : 
  2832. X        while(1){
  2833. X            printf(".");
  2834. X            sleep(4);
  2835. X        }    
  2836. X        break;
  2837. X  }
  2838. X  sprintf(s, "cp %s %s", ALLTIME, t );
  2839. X  system( s );
  2840. X  sprintf(s, "sort %s >> %s", CALLS, t );
  2841. X  system( s );
  2842. X
  2843. X  sprintf(s, THIRDCUT, t, m );
  2844. X  system( s );
  2845. X
  2846. X  kill( fpid, SIGKILL );
  2847. X  (void) wait( &fpid );
  2848. X  printf("%c", CR);
  2849. X
  2850. X  fp = fopen( m, "r" );
  2851. X  ff = fopen( t, "w" );
  2852. X
  2853. X  while(fgets(s, STRING, fp) != NULL){
  2854. X    if(atoi(s) > maxval) maxval = atoi(s);
  2855. X  }
  2856. X
  2857. X  rewind(fp);
  2858. X
  2859. X  while(fgets(o, STRING, fp) != NULL){
  2860. X    sscanf(o, "%s %s", s, z);
  2861. X    if(strlen(z) > 3){
  2862. X        i = atoi(z);
  2863. X        a = atoi(s);
  2864. X        fprintf(ff, "%12.12s '%2.2s  [%4.4d]  ", monat[i], strcopy(z, 3, 4), a);
  2865. X        i = ((54000L / maxval) * a)  / 1000;
  2866. X        if(i < 1) i = 1;
  2867. X        strcpy(s, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
  2868. X        s[i] = '\0';
  2869. X        if(toggle == 0){
  2870. X            strcpy(z, (UNSIGNED char *) termansi( "us" ));
  2871. X            toggle++;
  2872. X        }
  2873. X        else{
  2874. X            z[0] = '\0';
  2875. X            toggle = 0;    
  2876. X        }
  2877. X        fprintf(ff, "%s%s", z, s); 
  2878. X        strcpy(z, (UNSIGNED char *) termansi( "me" ));
  2879. X        fprintf(ff, "%s\n", z);    
  2880. X    }
  2881. X  }
  2882. X
  2883. X  if(USER.terminal != ISO6429){
  2884. X    fprintf(ff, "===============================================================================\n");
  2885. X  }
  2886. X  else{
  2887. X    strcpy(z, (UNSIGNED char *) termansi( "X1" ));
  2888. X    fprintf(ff, "%s%s\n", z, "                                                                               ");
  2889. X    strcpy(z, (UNSIGNED char *) termansi( "me" ));
  2890. X    fprintf(ff, "%s", z);    
  2891. X  }
  2892. X
  2893. X  fclose(ff);
  2894. X  fclose(fp);
  2895. X
  2896. X  show( t, 9999, USER.more + 100 );
  2897. X
  2898. X  unlink( t );
  2899. X  unlink( m );
  2900. X}
  2901. X
  2902. X
  2903. X/* #AU - Print the usage of terminal ports */
  2904. X
  2905. Xvoid auslastung()
  2906. X{
  2907. X  FILE *fp;
  2908. X
  2909. X  UNSIGNED char s[STRING];
  2910. X  UNSIGNED char d[STRING];
  2911. X  UNSIGNED char t[STRING];
  2912. X  UNSIGNED char dat[STRING];
  2913. X
  2914. X  int zeit = 0, i, l = 5, cal = 0;
  2915. X  int std, min, sec, per;
  2916. X
  2917. X  headblock( PD63_MSG, PD64_MSG );
  2918. X  strcpy(dat, (UNSIGNED char *) "00.00.00");
  2919. X  
  2920. X  fp = fopen( MBSTAT, "r" );
  2921. X  if(fp == NULL){
  2922. X  }
  2923. X  while(fgets(s, STRING, fp) != NULL){
  2924. X    sscanf(s, "%s %s %d", &d, &t, &i);    
  2925. X
  2926. X    if(strcomp("00.00.00", dat) == 0){
  2927. X        strcpy(dat, (UNSIGNED char *) d);
  2928. X    }
  2929. X
  2930. X    if(strcomp(dat, d) != 0){
  2931. X
  2932. X        std = zeit / 3600;
  2933. X                min = (zeit - (std * 3600)) / 60;
  2934. X                sec = zeit - (std * 3600) - (min * 60);
  2935. X        per = 10000 / 864 * zeit / 10000;
  2936. X
  2937. X        printf("%s  %2d:%02d:%02d    ", dat, std, min, sec);
  2938. X        ansi( "md", 0, 0 );
  2939. X        printf("%3d%%", per);
  2940. X        ansi( "me", 0, 0 );
  2941. X        printf("     %4d\n", cal);
  2942. X        l++;
  2943. X            
  2944. X        strcpy(dat, (UNSIGNED char *) d);
  2945. X        zeit = 0; cal = 0;
  2946. X    
  2947. X        if(l > USER.tlines){
  2948. X            fclose(fp);
  2949. X            goto MUST_LEAVE;
  2950. X        }
  2951. X    }
  2952. X    zeit += i;
  2953. X    cal++;
  2954. X  }
  2955. X  fclose(fp); 
  2956. X
  2957. X  std = zeit / 3600;
  2958. X  min = (zeit - (std * 3600)) / 60;
  2959. X  sec = zeit - (std * 3600) - (min * 60);
  2960. X  per = 10000 / 864 * zeit / 10000;
  2961. X
  2962. X
  2963. X  printf("%s  %2d:%02d:%02d    ", dat, std, min, sec);
  2964. X  ansi( "md", 0, 0 );
  2965. X  printf("%3d%%", per);
  2966. X  ansi( "me", 0, 0 );
  2967. X  printf("     %4d\n", cal);
  2968. X
  2969. X  MUST_LEAVE:
  2970. X
  2971. X  printf("\n%s\n%s ", PD65_MSG, PD66_MSG);
  2972. X  ansi( "md", 0, 0 );
  2973. X  printf("200%%");
  2974. X  ansi( "me", 0, 0 );
  2975. X  printf(" %s\n", PD67_MSG);
  2976. X}
  2977. END_OF_FILE
  2978.   if test 23193 -ne `wc -c <'mbox/src/pd.c'`; then
  2979.     echo shar: \"'mbox/src/pd.c'\" unpacked with wrong size!
  2980.   fi
  2981.   # end of 'mbox/src/pd.c'
  2982. fi
  2983. if test -f 'mbox/src/xmd.c' -a "${1}" != "-c" ; then 
  2984.   echo shar: Will not clobber existing file \"'mbox/src/xmd.c'\"
  2985. else
  2986.   echo shar: Extracting \"'mbox/src/xmd.c'\" \(17585 characters\)
  2987.   sed "s/^X//" >'mbox/src/xmd.c' <<'END_OF_FILE'
  2988. X/* ix/MBox (xmd.c) by Volker Schuermann, 04.12.1993
  2989. X
  2990. X   This C source code contains the following functions:
  2991. X
  2992. X   #ET elapsed_time()    calculate the delivering time
  2993. X   #BR brief()           mail a letter to a BBS user
  2994. X   #IS is_external()     old gateway stuff (forget about it)
  2995. X   #MI mailing()         find users BBS username
  2996. X   #MA main()            XMD main function
  2997. X
  2998. X   Contact <volkers@unnet.wupper.de> for help! */
  2999. X
  3000. X
  3001. X
  3002. X
  3003. X
  3004. X#include <sys/types.h>
  3005. X#include <sys/stat.h>
  3006. X#include <unistd.h>
  3007. X#include <stdio.h>
  3008. X#include <fcntl.h>
  3009. X#include <time.h>
  3010. X
  3011. X#include "mbox.h"
  3012. X
  3013. X
  3014. XUNSIGNED char tmp[STRING];
  3015. XUNSIGNED char alias[MAX_XMD_ALIAS][2][STRING];
  3016. XUNSIGNED char x400[STRING];
  3017. Xint INTERACT;
  3018. X
  3019. X
  3020. X
  3021. X
  3022. X/* #ET - Calculates the delivering time out of a "Date:" header line [hd].
  3023. X
  3024. X   This function returns a "X-Delivering-Time:" header line. */
  3025. X
  3026. XUNSIGNED char *elapsed_time( hd )
  3027. XUNSIGNED char hd[];
  3028. X{
  3029. X  UNSIGNED char tag[STRING];
  3030. X  UNSIGNED char monat[STRING];
  3031. X  UNSIGNED char jahr[STRING];
  3032. X  UNSIGNED char zeit[STRING];
  3033. X  UNSIGNED char zone[STRING];
  3034. X
  3035. X  UNSIGNED char s[STRING];
  3036. X  UNSIGNED char t[STRING];
  3037. X  UNSIGNED char mon[12][4];
  3038. X
  3039. X  UNSIGNED char tzcode[STRING];
  3040. X  UNSIGNED char tzfact[STRING];
  3041. X  UNSIGNED char tzname[STRING];
  3042. X
  3043. X  int i = 0, a = 0;
  3044. X
  3045. X  long ljahr, lzeit;
  3046. X  long njahr, nzeit;
  3047. X
  3048. X  FILE *fp;
  3049. X
  3050. X
  3051. X  strcpy(mon[ 1], "Jan");
  3052. X  strcpy(mon[ 2], "Feb");
  3053. X  strcpy(mon[ 3], "Mar");
  3054. X  strcpy(mon[ 4], "Apr");
  3055. X  strcpy(mon[ 5], "May");
  3056. X  strcpy(mon[ 6], "Jun");
  3057. X  strcpy(mon[ 7], "Jul");
  3058. X  strcpy(mon[ 8], "Aug");
  3059. X  strcpy(mon[ 9], "Sep");
  3060. X  strcpy(mon[10], "Oct");
  3061. X  strcpy(mon[11], "Nov");
  3062. X  strcpy(mon[12], "Dec");
  3063. X
  3064. X  while((a == 0) && (hd[i] != '\0')){
  3065. X    if((hd[i] >= '0') && (hd[i] <= '9')) a = i;
  3066. X    i++;
  3067. X  }
  3068. X
  3069. X  strcpy(s, (UNSIGNED char *) strcopy(hd, a, (strlen(hd))));
  3070. X
  3071. X  sscanf(s, "%s %s %s %s %s", tag, monat, jahr, zeit, zone);
  3072. X  for(i = 1; i <= 12; i++){
  3073. X    if(strcomp(mon[i], monat) == 0) a = i;
  3074. X  }
  3075. X
  3076. X  sprintf(s, "%02.2d.%02.2d.%02.2d", atoi(tag), a, atoi(jahr));
  3077. X  ljahr = dateconv( (UNSIGNED char *) s );
  3078. X
  3079. X  lzeit = (long) (atol( strcopy(zeit, 0, 1) ) * 60) + (atol(strcopy(zeit, 3, 4)));
  3080. X  
  3081. X  strcpy(s, (UNSIGNED char *) mydate( 0 ));
  3082. X  njahr = dateconv( (UNSIGNED char *) s );
  3083. X
  3084. X  strcpy(s, (UNSIGNED char *) mytime( 0 ));
  3085. X  nzeit = (long) (atol( strcopy(s, 0, 1) ) * 60) + (atol(strcopy(s, 3, 4)));
  3086. X
  3087. X  if((zone[1] >= '0') && (zone[1] <= '9')){     /* +0500, -0100, ...  */
  3088. X    strcpy(tzfact, (UNSIGNED char *) zone);
  3089. X    tzname[0] = '\0';
  3090. X  }
  3091. X  else{                        /* GMT, CET, EET, ... */
  3092. X    fp = fopen( TIMEZONES, "r" );
  3093. X    if(fp == NULL){
  3094. X        sprintf(t, "XMD-FILE-NOT-FOUND: %s\n", (UNSIGNED char *) TIMEZONES);
  3095. X        return (UNSIGNED char *) t;
  3096. X    }
  3097. X    while((fgets(s, STRING, fp) != NULL) && (s[0] != '='));
  3098. X    while(fgets(s, STRING, fp) != NULL){
  3099. X        sscanf(s, "%s", t);
  3100. X        if(strcomp(zone, t) == 0){
  3101. X            sscanf(s, "%s %s", tzcode, tzfact);    
  3102. X            strcpy(tzname, (UNSIGNED char *) stripped(strcopy(s, 19, strlen(s))));
  3103. X        }
  3104. X    }
  3105. X    fclose(fp);
  3106. X  }
  3107. X
  3108. X  strcpy(s, (UNSIGNED char *) GMT_DIFF);    
  3109. X  if(s[0] == '-'){
  3110. X    s[0] = ' ';
  3111. X    nzeit += (long) (atol(s) * 60 / 100); 
  3112. X  }
  3113. X  else{
  3114. X    s[0] = ' ';
  3115. X    nzeit -= (long) (atol(s) * 60 / 100); 
  3116. X  }
  3117. X  
  3118. X  if(tzfact[0] == '-'){
  3119. X      tzfact[0] = ' ';
  3120. X    lzeit += (long) (atol(tzfact) * 60 / 100); 
  3121. X  }
  3122. X  else{
  3123. X    tzfact[0] = ' ';
  3124. X    lzeit -= (long) (atol(tzfact) * 60 / 100); 
  3125. X  }
  3126. X  
  3127. X  njahr -= ljahr; 
  3128. X
  3129. X  if(njahr > 30){
  3130. X    njahr -= 70;    
  3131. X  }
  3132. X  if(njahr > 30){
  3133. X    return( (UNSIGNED char *) "X-Delivering-Time: Not able to calculate!\n" );
  3134. X  }
  3135. X
  3136. X  nzeit -= lzeit;
  3137. X  
  3138. X  if(nzeit < 0){
  3139. X    nzeit += (24 * 60);
  3140. X    njahr -= 1;
  3141. X  }
  3142. X
  3143. X  if(njahr > 0){
  3144. X    sprintf(s, "X-Delivering-Time: %ld day(s), %ld hour(s) and %ld minute(s)",
  3145. X          (long) njahr, 
  3146. X          (long) (nzeit / 60), 
  3147. X          (long) (nzeit - ((nzeit / 60) * 60)));
  3148. X  }
  3149. X  else{
  3150. X    sprintf(s, "X-Delivering-Time: %ld hour(s) and %ld minute(s)",
  3151. X          (long) (nzeit / 60), 
  3152. X          (long) (nzeit - ((nzeit / 60) * 60)));    
  3153. X  }
  3154. X
  3155. X  if(tzname[0] != '\0'){
  3156. X    sprintf(t, "; %s", tzname);
  3157. X    strcat(s, t);
  3158. X  }
  3159. X
  3160. X  strcat(s, "\n");
  3161. X
  3162. X
  3163. X  return (UNSIGNED char *) s;
  3164. X}
  3165. X
  3166. X
  3167. X
  3168. Xvoid log_it( s1, s2, s3 )
  3169. XUNSIGNED char s1[], s2[], s3[];
  3170. X{
  3171. X  FILE *ff;
  3172. X
  3173. X
  3174. X  ff = fopen( XMDLOG, "a" );
  3175. X  if(ff == NULL){
  3176. X    printf("\nCan't open %s\n", XMDLOG);
  3177. X    return;
  3178. X  }
  3179. X  fprintf(ff, "%5.5s  %5.5s > %-29.29s   [%s %s]\n",
  3180. X    (UNSIGNED char *) mydate( 1 ), (UNSIGNED char *) mytime( 1 ),
  3181. X        (UNSIGNED char *) s1, s2, s3);
  3182. X  fclose(ff);
  3183. X}
  3184. X
  3185. X
  3186. X
  3187. X/* #BR - Mail to a BBS user [arg]. */
  3188. X
  3189. Xbrief(arg)
  3190. XUNSIGNED char arg[];
  3191. X{
  3192. X  FILE *fp;
  3193. X  FILE *ff;
  3194. X  int fd;
  3195. X  int i, a, b;
  3196. X  int ok;
  3197. X  struct userdaten LOOSER;
  3198. X
  3199. X  struct tm *timeptr;
  3200. X  time_t timer;
  3201. X
  3202. X  int receiver;
  3203. X  static int mail_id;
  3204. X  int EX_PM   = 0;
  3205. X  int REPLY   = 0;
  3206. X  int lines   = 0;
  3207. X  int local   = 0;
  3208. X  int arrived = 1;
  3209. X
  3210. X  int yet_new = 0;
  3211. X
  3212. X
  3213. X  UNSIGNED char s[STRING];
  3214. X  UNSIGNED char t[STRING];
  3215. X  UNSIGNED char top[STRING];
  3216. X  UNSIGNED char subject[STRING];
  3217. X  UNSIGNED char autor[STRING];
  3218. X  UNSIGNED char rec_char[STRING];
  3219. X  UNSIGNED char ex[LONGSTRING];
  3220. X  UNSIGNED char user[STRING];
  3221. X  UNSIGNED char c;
  3222. X  UNSIGNED char protokoll;
  3223. X  UNSIGNED char destination[STRING];
  3224. X  UNSIGNED char receipt[STRING];
  3225. X
  3226. X  i = 0;
  3227. X  ok = 0;
  3228. X
  3229. X
  3230. X  strcpy(user, (UNSIGNED char *) stripped(arg));
  3231. X  strcpy(subject, XMD01_MSG);
  3232. X
  3233. X  JUNK:    receiver = 0;
  3234. X
  3235. X  fd = open(UDBASE, O_RDONLY);
  3236. X  if (fd == -1) {
  3237. X    log_it( "Can't read:", UDBASE, "!" );
  3238. X    printf("\nCan't read %s\n", UDBASE);
  3239. X    exit(-1);
  3240. X  }
  3241. X  lseek(fd, 0L, SEEK_SET);
  3242. X  while ((read(fd, (UNSIGNED char *) &LOOSER, sizeof(LOOSER)) == sizeof(LOOSER)) && (receiver == 0)) {
  3243. X    if ((strcomp(user, LOOSER.name) == 0) ||
  3244. X        (strcomp(LOOSER.name, user) == 0) ||
  3245. X        (strcomp(user, LOOSER.nick) == 0) ||
  3246. X        (strcomp(user, LOOSER.sh_name) == 0)) {
  3247. X        receiver = LOOSER.id;
  3248. X        strcpy(rec_char, LOOSER.name);
  3249. X    }
  3250. X  }
  3251. X  close(fd);
  3252. X
  3253. X  if (receiver == 0) {
  3254. X    sprintf(subject, "[xmd:] '%s' ???   ", user);
  3255. X    strcpy(user, POSTMASTER);
  3256. X    arrived = 0;
  3257. X    goto JUNK;
  3258. X  }
  3259. X  sprintf(s, "%s/usr/%d/seq", HOME, receiver);
  3260. X  maybe_locked(s, "r"); mblock(s);
  3261. X  fp = fopen(s, "r");
  3262. X  if(fp == NULL){
  3263. X    yet_new = 1;
  3264. X    sprintf(s, "%s/usr/%c/%d/seq", HOME, rec_char[0], receiver);
  3265. X    fp = fopen(s, "r");
  3266. X    if(fp == NULL){
  3267. X        log_it( "Can't read:", s, "!" );
  3268. X        printf("\nCan't read %s\n", s);
  3269. X        exit(-1);
  3270. X    }
  3271. X  }
  3272. X  fgets(s, STRING, fp);
  3273. X  mail_id = atoi( s );
  3274. X  fclose(fp);
  3275. X
  3276. X  if(yet_new == 0)
  3277. X    sprintf(destination, "%s/usr/%d/%d", HOME, receiver, mail_id);
  3278. X  else
  3279. X    sprintf(destination, "%s/usr/%c/%d/%d", HOME, rec_char[0], receiver, mail_id);
  3280. X
  3281. X  fp = fopen(destination, "w");
  3282. X  if(fp == NULL){
  3283. X    log_it( "Can't write to:", destination, "!" );
  3284. X    printf("\nCan't write to %s\n", destination);
  3285. X  }
  3286. X
  3287. X  sprintf(s, "%s %s (%s)\n", GBL01_MSG, X_MAIL_DEMON, "xmd");
  3288. X  fputs(s, fp);
  3289. X
  3290. X  time(&timer);
  3291. X  timeptr = localtime(&timer);
  3292. X  strcpy(t, (UNSIGNED char *) asctime(timeptr));
  3293. X
  3294. X  sprintf(s, "%s %s", GBL02_MSG, t);
  3295. X  fputs(s, fp);
  3296. X
  3297. X  sprintf(s, "%s %s\n\n", GBL03_MSG, subject);
  3298. X  fputs(s, fp);
  3299. X
  3300. X  fprintf(fp, "%s\n\n", XMD02_MSG);
  3301. X
  3302. X  lines = 7;
  3303. X
  3304. X  autor[0] = '\0';
  3305. X  subject[0] = '\0';
  3306. X
  3307. X  ff = fopen(tmp, "r");
  3308. X  if (ff == NULL) {
  3309. X    return;
  3310. X  }
  3311. X  while (fgets(s, STRING, ff) != NULL) {
  3312. X    i = 0;
  3313. X
  3314. X    if(strcomp("*From ", s) == 0){
  3315. X        strcpy(s, (UNSIGNED char *) stripped(strcopy(s, 1, STRING)));
  3316. X        strcat(s, "\n");
  3317. X    }
  3318. X    if(strcomp("Date: ", s) == 0){
  3319. X        fputs(elapsed_time( s ), fp);
  3320. X    }
  3321. X    fputs(s, fp);
  3322. X    lines++;
  3323. X    if((strcomp("Subject: ", s) == 0) && (subject[0] == '\0')){
  3324. X        strcpy(subject, (UNSIGNED char *) stripped(strcopy(s, 9, STRING)));
  3325. X    }
  3326. X    if((strcomp("From: ", s) == 0) && ((autor[0] == '\0') || (local = 1))){
  3327. X        strcpy(autor, (UNSIGNED char *) stripped(strcopy(s, 6, STRING)));
  3328. X        local = 0;
  3329. X    }
  3330. X    if(strcomp("From ", s) == 0){
  3331. X        strcpy(autor, (UNSIGNED char *) stripped(strcopy(s, 5, STRING)));
  3332. X        local = 1;
  3333. X    }
  3334. X    if(strcomp("*From ", s) == 0){
  3335. X        strcpy(autor, (UNSIGNED char *) stripped(strcopy(s, 6, STRING)));
  3336. X        local = 1;
  3337. X    }
  3338. X    if(strcomp("Return-Receipt-To: ", s) == 0){
  3339. X        strcpy(receipt, (UNSIGNED char *) stripped(strcopy(s, 19, STRING)));
  3340. X    }
  3341. X    if(strcomp("X-Return-Receipt-To: ", s) == 0){
  3342. X        strcpy(receipt, (UNSIGNED char *) stripped(strcopy(s, 19, STRING)));
  3343. X    }
  3344. X  }
  3345. X  fclose(ff);
  3346. X  fclose(fp);
  3347. X
  3348. X  i = 0; 
  3349. X  while(autor[i] != '\0'){
  3350. X    if(autor[i] == '(') autor[(i-1)] = '\0';
  3351. X    i++;
  3352. X  }
  3353. X
  3354. X  if((local == 1) && (strcomp("postmaster", autor) == 0)){
  3355. X    fclose(fp);
  3356. X    unlink(destination);
  3357. X    if(INTERACT == 0) printf("[%s]\n", arg);
  3358. X    fp = fopen( XMDLOG, "a" );
  3359. X    if(fp == NULL){
  3360. X        printf("\nCan't append to %s\n", XMDLOG);
  3361. X        return;
  3362. X    }
  3363. X    fprintf(fp, "%-29.29s   %33.33s\n", (UNSIGNED char *) stripped(arg), subject);
  3364. X    fclose(fp);
  3365. X    return;
  3366. X  }
  3367. X
  3368. X  if(yet_new == 0)
  3369. X    sprintf(s, "%s/usr/%d/INDEX", HOME, receiver);
  3370. X  else
  3371. X    sprintf(s, "%s/usr/%c/%d/INDEX", HOME, rec_char[0], receiver);
  3372. X
  3373. X  fp = fopen(s, "a");
  3374. X  if(fp == NULL){
  3375. X    log_it( "Can't append to:", s, "!" );
  3376. X    printf("\nCan't append to %s\n", s);
  3377. X    return;
  3378. X  }
  3379. X
  3380. X  sprintf(s, "%d              ", mail_id);
  3381. X  s[6] = '\0';
  3382. X  fputs(s, fp);
  3383. X
  3384. X  sprintf(ex, "%s                                  ", subject);
  3385. X  ex[26] = '\0';
  3386. X  fputs(ex, fp);
  3387. X
  3388. X  sprintf(ex, "  %s                                        ", autor);
  3389. X  ex[22] = '\0';
  3390. X  fputs(ex, fp);
  3391. X
  3392. X
  3393. X  strcpy(s, (UNSIGNED char *) mydate(1));
  3394. X  strcpy(t, (UNSIGNED char *) mytime(1));
  3395. X  sprintf(ex, "  %s  %s         ", s, t);
  3396. X  ex[19] = '\0';
  3397. X  fputs(ex, fp);
  3398. X  sprintf(s, "%s\n", LE215_MSG);
  3399. X  fputs(s, fp);
  3400. X
  3401. X  fclose(fp);
  3402. X
  3403. X  if(yet_new == 0)
  3404. X    sprintf(s, "%s/usr/%d/seq", HOME, receiver);
  3405. X  else
  3406. X    sprintf(s, "%s/usr/%c/%d/seq", HOME, rec_char[0], receiver);
  3407. X
  3408. X  fp = fopen(s, "w");
  3409. X  if(fp == NULL){
  3410. X    log_it( "Can't write to:", s, "!" );
  3411. X    printf("\nCan't write to %s\n", s);
  3412. X  }
  3413. X  rewind(fp);
  3414. X  fprintf(fp, "%d\n", (int) (mail_id + 1));
  3415. X  fclose(fp);
  3416. X  mbunlock(s);
  3417. X
  3418. X  if(INTERACT == 0) printf("%s\n", arg);
  3419. X
  3420. X  ff = fopen( XMDLOG, "a" );
  3421. X  if(ff == NULL){
  3422. X    printf("\nCan't append to %s\n", XMDLOG);
  3423. X    return;
  3424. X  }
  3425. X  fprintf(ff, "%5.5s  %5.5s   %-29.29s   %-31.31s\n", 
  3426. X      (UNSIGNED char *) mydate( 1 ), (UNSIGNED char *) mytime( 1 ),
  3427. X      (UNSIGNED char *) stripped(arg), subject);
  3428. X  fclose(ff);
  3429. X
  3430. X  if(receipt[0] != '\0'){
  3431. X    i = 0; b = 0;
  3432. X    while(receipt[i] != '\0'){
  3433. X        if(receipt[i] == '!') b = i;
  3434. X        if(receipt[i] == '@') b = i;
  3435. X        i++;
  3436. X    }
  3437. X    if(b == 0) return;
  3438. X     i = b; a = 0;
  3439. X    while((i > 0) && (a == 0)){
  3440. X        if((receipt[i] == ' ') ||
  3441. X           (receipt[i] == '<') ||
  3442. X           (receipt[i] == '(')) a = i + 1;
  3443. X        i--;
  3444. X    }
  3445. X      i = b; b = 0;
  3446. X     while((receipt[i] != '\0') && (b == 0)){
  3447. X        if((receipt[i] == ' ') ||
  3448. X           (receipt[i] == '>') ||
  3449. X           (receipt[i] == ')')) b = i -1;
  3450. X        i++;
  3451. X    }
  3452. X    if(b == 0) b = i -1;
  3453. X     strcpy(receipt, (UNSIGNED char *) strcopy(receipt, a, b));
  3454. X
  3455. X    sprintf(t, "%s/%d.REC", TMP, getpid());
  3456. X    ff = fopen( t, "w" );    
  3457. X    if(ff == NULL){
  3458. X        log_it( "Can't write to:", t, "!" );
  3459. X        printf("\nCan't write to %s\n", t);
  3460. X      }
  3461. X
  3462. X    time(&timer);
  3463. X
  3464. X    fprintf(ff, "From: XMD@%s\n", UUCPID2); 
  3465. X    fprintf(ff, "Sender: postmaster@%s (Die Postmeisterei)\n", UUCPID2);
  3466. X    fprintf(ff, "Organization: %s\n", ORGANIZATION);
  3467. X    fprintf(ff, "To: %s\n", receipt);
  3468. X    fprintf(ff, "Subject: Delivering Report\n");
  3469. X    fprintf(ff, "X-Mailer: %s %s %s\n", VERSION, PATCHLEVEL, AUTOR);    
  3470. X    fprintf(ff, "Message-Id: <%x.xmd@%s>\n", timer, UUCPID2);
  3471. X    fputs("\n", ff);
  3472. X
  3473. X    fprintf(ff, "Wuppertal (FRG), %s at %s\n\n", mydate( 1 ), mytime( 1 ));
  3474. X
  3475. X    fprintf(ff, "Your mail \"%s\" ...\n", subject);
  3476. X    if(arrived == 1){
  3477. X        fprintf(ff, "reached %s.\n\nBye now!\n", (UNSIGNED char *) stripped(arg));
  3478. X    }
  3479. X    else{
  3480. X        fprintf(ff, "couldn't be delivered to %s.\n\n", (UNSIGNED char *) stripped(arg));
  3481. X        fprintf(ff, "The local postmaster got a copy of your mail! Maybe he is able to forward it\nto the correct receipient!\n\n");
  3482. X    }
  3483. X    fclose(ff);
  3484. X
  3485. X    sprintf(s, "/bin/sh %s/etc/rmail.sh %s %s", HOME, t, receipt);
  3486. X    system(s);
  3487. X    unlink( t );
  3488. X  }
  3489. X}
  3490. X
  3491. X
  3492. X
  3493. X
  3494. X/* #IS - Old gateway stuff. */
  3495. X
  3496. Xint is_external( s )
  3497. XUNSIGNED char s[];
  3498. X{
  3499. X  int i = 0, j = 0, p = 0;
  3500. X
  3501. X  if(strcomp("To: Empty Address", s) == 0) return (int) -1;
  3502. X
  3503. X  while(s[i] != '\0'){
  3504. X    if(s[i] == '%') j++;
  3505. X    if((s[i] == '@') && (j > 0)) p = i;
  3506. X    i++;
  3507. X  }
  3508. X  return (int) p;
  3509. X}
  3510. X
  3511. X
  3512. X
  3513. X/* #MI - Finding a BBS username in a UUCP address and calling "brief()"
  3514. X   with this address. */
  3515. X
  3516. Xmailing()
  3517. X{
  3518. X  FILE *fp;
  3519. X  FILE *ff;
  3520. X  UNSIGNED char s[LONGSTRING];
  3521. X  UNSIGNED char t[STRING];
  3522. X  int i, j;
  3523. X  int toggle = 0;
  3524. X
  3525. X  fp = fopen(tmp, "r");
  3526. X  if (fp == NULL) {
  3527. X    log_it( "Can't read:", tmp, "!" );
  3528. X    printf("\nCan't read %s\n", tmp);
  3529. X    exit(-1);
  3530. X  }
  3531. X  while (fgets(s, STRING, fp) != NULL) {
  3532. X    if ((strcomp("X400-Recipients:", s) == 0) && (toggle == 0)){
  3533. X        i = 16;
  3534. X        j = 0;
  3535. X        while(s[i] != '\0'){
  3536. X            if(s[i] == '<') j = i+1;
  3537. X            if(s[i] == '@'){
  3538. X                strcpy(x400, (UNSIGNED char *) strcopy(s, j, (i-1)));
  3539. X            }
  3540. X            i++;
  3541. X        }
  3542. X    }
  3543. X    if ((strcomp("To:", s) == 0) && (toggle == 0)){
  3544. X        i = 1;
  3545. X        toggle++;
  3546. X        while(strcomp("EOL", alias[i][1]) != 0){    
  3547. X            if(strcomp(alias[i][1], s) == 0) strcpy(s, alias[i][2]);
  3548. X            i++;
  3549. X        }
  3550. X
  3551. X        i = 0;
  3552. X        j = 0;
  3553. X        while ((s[i] != '\0') && (s[i] != '@')) {
  3554. X            if (s[i] == '!') j = i;
  3555. X            if (s[i] == '.') s[i] = ' ';
  3556. X            i++;
  3557. X        }
  3558. X        i--;
  3559. X        if (j == 0) {
  3560. X            strcpy(t, (UNSIGNED char *) strcopy(s, 4, i));
  3561. X        } else {
  3562. X            strcpy(t, (UNSIGNED char *) strcopy(s, (j + 1), strlen(s)));
  3563. X        }
  3564. X
  3565. X        if(t[0] == '"'){
  3566. X            j = 1;
  3567. X            while((t[j] != '\0') && (t[j] != '"')){
  3568. X                j++;
  3569. X            }
  3570. X            j--;
  3571. X            strcpy(t, (UNSIGNED char *) strcopy(t, 1, j));
  3572. X        }
  3573. X
  3574. X        if(is_external(s) == 0){
  3575. X            brief(t);
  3576. X        }
  3577. X        else{    
  3578. X            if(strcomp("Empty Address", t) == 0){
  3579. X                strcpy(t, (UNSIGNED char *) x400);
  3580. X            }
  3581. X            sprintf(s, "rmail -v -d -i %s %s@amnet.UUCP", tmp, t);
  3582. X            if(INTERACT == 0) printf("%s\n", t);
  3583. X            system( s );
  3584. X            ff = fopen( XMDLOG, "a" );
  3585. X            if(ff == NULL){
  3586. X                printf("\nCan't open %s\n", XMDLOG);
  3587. X                return;
  3588. X            }
  3589. X            fprintf(ff, "%5.5s  %5.5s > %-29.29s   [Gateway]\n", 
  3590. X                (UNSIGNED char *) mydate( 1 ), (UNSIGNED char *) mytime( 1 ),
  3591. X                    (UNSIGNED char *) t);
  3592. X            fclose(ff);
  3593. X        }
  3594. X    }
  3595. X  }
  3596. X
  3597. X  fclose(fp);
  3598. X}
  3599. X
  3600. X
  3601. X
  3602. X
  3603. X
  3604. X/* #MA - XMD main function. 
  3605. X
  3606. X   This is able to forward mails to addresses such as "Real.Name@UUCPID". 
  3607. X
  3608. X   It also understands "Real.Name -" command lines. This is used by smail
  3609. X   in the "aliases" file. The mailing text has to come from stdin than. */
  3610. X
  3611. Xmain(argc, argv)
  3612. Xint argc;
  3613. XUNSIGNED char *argv[];
  3614. X{
  3615. X  FILE *fp;
  3616. X  FILE *ff;
  3617. X  UNSIGNED char s[LONGSTRING];
  3618. X  UNSIGNED char t[LONGSTRING];
  3619. X  UNSIGNED char u[LONGSTRING];
  3620. X  UNSIGNED char dump[STRING];
  3621. X  UNSIGNED char maildrop[STRING];
  3622. X  int toggle = 0;
  3623. X  int l;
  3624. X  int c;
  3625. X  int p;
  3626. X  int i;
  3627. X  int j;
  3628. X
  3629. X
  3630. X  setuid(0);
  3631. X  setgid(0);
  3632. X  umask(0000);
  3633. X
  3634. X  chdir(HOME);
  3635. X
  3636. X
  3637. X
  3638. X  if(argc < 2){
  3639. X    maybe_locked(ERRMBOX, "r"); mblock(ERRMBOX);
  3640. X    fp = fopen(ERRMBOX, "r");
  3641. X    INTERACT = 0;
  3642. X  }
  3643. X  else{
  3644. X    if(argv[2][0] == '-'){
  3645. X        sprintf(maildrop, "%s/%dPIP", TMP, getpid());
  3646. X        fp = fopen(maildrop, "w");
  3647. X        if(fp == NULL){
  3648. X            log_it( "Can't write to:", maildrop, "!" );
  3649. X            log_it( "Mail LOST! No SETUID for XMD!!!", "CHMOD ug+s xmd", "IMMEDIATLY!!!" );
  3650. X            printf("\nCan't write to %s\n", maildrop);
  3651. X            return;
  3652. X        }
  3653. X        c = 0;
  3654. X        do{
  3655. X            c = fgetc(stdin);
  3656. X            if((c != EOF) && (c != 4)){
  3657. X                fputc(c, fp);
  3658. X            }
  3659. X        }while((c != EOF) && (c != 4));
  3660. X        fclose(fp);
  3661. X        fp = fopen(maildrop, "r");
  3662. X        INTERACT = 1;    
  3663. X    }
  3664. X    else{
  3665. X        maybe_locked(maildrop, "r"); mblock(maildrop);
  3666. X        sprintf(maildrop, "%s/%s", MAILDROP, argv[1]);
  3667. X        fp = fopen(maildrop, "r");
  3668. X        INTERACT = 1;
  3669. X    }
  3670. X  }
  3671. X  if(INTERACT == 0) printf("\n");
  3672. X
  3673. X  if (fp == NULL) {
  3674. X    if(INTERACT == 0) printf("\nNo mail.\n");
  3675. X    return;
  3676. X  }
  3677. X
  3678. X  l = 1; 
  3679. X  ff = fopen( XMD_ALIAS, "r" );
  3680. X  if(ff != 0){
  3681. X    while(fgets(s, STRING, ff) != 0){
  3682. X        if((s[0] > 64) && (l < MAX_XMD_ALIAS)){
  3683. X            strcpy(alias[l][1], (UNSIGNED char *) stripped(s));
  3684. X            fgets(s, STRING, ff);
  3685. X            strcpy(alias[l][2], (UNSIGNED char *) stripped(s));
  3686. X            l++;
  3687. X        }
  3688. X    }
  3689. X    fclose(ff);
  3690. X  }
  3691. X  strcpy(alias[l][1], "EOL");
  3692. X
  3693. X  sprintf(dump, "%s/%d.DUMP", TMP, getpid());
  3694. X  ff = fopen(dump, "w");
  3695. X  if(ff == NULL){
  3696. X    log_it( "Can't write to:", dump, "!" );
  3697. X    printf("\nCan't write to %s\n", dump);
  3698. X    return;
  3699. X  }
  3700. X
  3701. X  toggle = 0;
  3702. X
  3703. X  while (fgets(s, STRING, fp) != NULL) {
  3704. X    l = 2;
  3705. X    if (s[0] == '>') {
  3706. X        if(s[1] != ' ') l = 1;
  3707. X        strcpy(t, (UNSIGNED char *) strcopy(s, l, strlen(s)));
  3708. X        strcpy(s, t);
  3709. X        if (strcomp("OOPS", s) != 0) {
  3710. X            fputs(s, ff);
  3711. X        }
  3712. X    }
  3713. X    else{
  3714. X        if(strcomp("From ", s) == 0){
  3715. X            fprintf(ff, "*%s", s);
  3716. X            if(strcomp(RETURNED_MAIL, s) == 0){
  3717. X                while(strcomp("> ", s) != 0){
  3718. X                    fgets(s, STRING, fp);
  3719. X                }
  3720. X            }
  3721. X        }
  3722. X        else{
  3723. X            fputs(s, ff);
  3724. X        }
  3725. X    }
  3726. X
  3727. X  }
  3728. X  fclose(ff);
  3729. X  fclose(fp);
  3730. X
  3731. X  fp = fopen(dump, "r");
  3732. X  if(fp == NULL){
  3733. X    log_it( "Can't read:", dump, "!" );
  3734. X    printf("\nCan't read %s\n", dump);
  3735. X    return;
  3736. X  }
  3737. X
  3738. X  sprintf(tmp, "%s/%d.XMD", TMP, getpid());
  3739. X
  3740. X  ff = fopen(tmp, "w");
  3741. X  if(ff == NULL){
  3742. X    log_it( "Can't write to:", tmp, "!" );
  3743. X    printf("\nCan't write to %s\n", tmp);
  3744. X    return;
  3745. X  }
  3746. X
  3747. X  toggle = 0;
  3748. X
  3749. X  while (fgets(s, STRING, fp) != NULL) {
  3750. X    if (strcomp("*From ", s) == 0){
  3751. X        if (toggle == 1) {
  3752. X            if (ff != 0) fclose(ff);
  3753. X            mailing();
  3754. X            ff = fopen(tmp, "w");
  3755. X            if(ff == NULL){
  3756. X                log_it( "Can't write to:", tmp, "!" );
  3757. X                printf("\nCan't write to %s\n", tmp);
  3758. X                return;
  3759. X            }
  3760. X        }
  3761. X        toggle = 1;
  3762. X    }
  3763. X    if ((toggle == 1) && (strcomp("*From ", s) != 0)){
  3764. X
  3765. X        if (strcomp("X400-Recipients:", s) == 0){
  3766. X            i = 16;
  3767. X            j = 0;
  3768. X            while(s[i] != '\0'){
  3769. X                if(s[i] == '<') j = i+1;
  3770. X                if(s[i] == '@'){
  3771. X                    strcpy(x400, (UNSIGNED char *) strcopy(s, j, (i-1)));
  3772. X                }
  3773. X                i++;
  3774. X            }
  3775. X        }        
  3776. X        
  3777. X        if(strcomp("To: ", s) == 0){
  3778. X            p = is_external(s);
  3779. X
  3780. X            if(p > 0){
  3781. X                s[p] = '\0';
  3782. X                strcat(s, (UNSIGNED char *) "@amnet.UUCP\n");
  3783. X            }
  3784. X            if(p == -1){
  3785. X                sprintf(s, "To: %s@amnet.UUCP\n", x400);
  3786. X            }
  3787. X        }
  3788. X        fputs(s, ff);
  3789. X    }
  3790. X  }
  3791. X  if (ff != 0) fclose(ff);
  3792. X  if (toggle == 1) mailing();
  3793. X  fclose(fp);
  3794. X
  3795. X  unlink(tmp);
  3796. X  unlink(dump);
  3797. X
  3798. X  if(INTERACT == 0){
  3799. X     sprintf(s, "> %s", ERRMBOX);
  3800. X    mbunlock(ERRMBOX);
  3801. X  }
  3802. X  else{
  3803. X    if(getgid() == GUEST_GID){
  3804. X         sprintf(s, "> %s", maildrop);
  3805. X        mbunlock(maildrop);
  3806. X    }
  3807. X  }
  3808. X  system(s);
  3809. X}
  3810. END_OF_FILE
  3811.   if test 17585 -ne `wc -c <'mbox/src/xmd.c'`; then
  3812.     echo shar: \"'mbox/src/xmd.c'\" unpacked with wrong size!
  3813.   fi
  3814.   # end of 'mbox/src/xmd.c'
  3815. fi
  3816. echo shar: End of archive 5 \(of 12\).
  3817. cp /dev/null ark5isdone
  3818. MISSING=""
  3819. for I in 1 2 3 4 5 6 7 8 9 10 11 12 ; do
  3820.     if test ! -f ark${I}isdone ; then
  3821.     MISSING="${MISSING} ${I}"
  3822.     fi
  3823. done
  3824. if test "${MISSING}" = "" ; then
  3825.     echo You have unpacked all 12 archives.
  3826.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  3827. else
  3828.     echo You still must unpack the following archives:
  3829.     echo "        " ${MISSING}
  3830. fi
  3831. exit 0
  3832. exit 0 # Just in case...
  3833.