home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Src / MTAconsole / parse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  4.5 KB  |  276 lines
  1. /* parse.c: various parsing routines */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Src/MTAconsole/RCS/parse.c,v 6.0 1991/12/18 20:26:48 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Src/MTAconsole/RCS/parse.c,v 6.0 1991/12/18 20:26:48 jpo Rel $
  9.  *
  10.  * $Log: parse.c,v $
  11.  * Revision 6.0  1991/12/18  20:26:48  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16.  
  17.  
  18. #include     "console.h"
  19.  
  20. /* convert a given string to time */
  21.  
  22. char    *unparsetime(mytime)
  23. unsigned long mytime;
  24. {
  25.     char    buf[BUFSIZ];
  26.     unsigned long result;
  27.     buf[0] = '\0';
  28.     if ((result = mytime / (60 * 60 * 24)) != 0) {
  29.         sprintf(buf, "%d d",result);
  30.         mytime = mytime % (60 * 60 *24);
  31.     }
  32.  
  33.     if ((result = mytime / (60 * 60)) != 0) {
  34.         sprintf(buf, (buf[0] == '\0') ? "%s%d h" : "%s %d h", 
  35.             buf, result);
  36.         mytime = mytime % (60 * 60);
  37.     }
  38.  
  39.     if ((result = mytime / 60 ) != 0) {
  40.         sprintf(buf, (buf[0] == '\0') ? "%s%d m" : "%s %d m", 
  41.             buf, result);
  42.         mytime = mytime % (60);
  43.     }
  44.  
  45.     if (mytime != 0) 
  46.         sprintf(buf, (buf[0] == '\0') ? "%s%d s" : "%s %d s",
  47.             buf, mytime);
  48.  
  49.     return strdup(buf);
  50. }
  51.  
  52. time_t parsetime(s)
  53. char    *s;
  54. {
  55.     int    n;
  56.     if (s == NULLCP || *s == NULL) return 0;
  57.     while(*s != NULL && isspace(*s)) s++;
  58.     n = 0;
  59.     while (*s != NULL && isdigit(*s)) {
  60.         n = n * 10 + *s - '0';
  61.         s++;
  62.     }
  63.     while (*s != NULL && isspace(*s)) s++;
  64.     if (*s != NULL && isalpha(*s)) {
  65.         switch (*s) {
  66.             case 's':
  67.             case 'S': 
  68.             break;
  69.             case 'm': 
  70.             case 'M':
  71.             n *= 60; 
  72.             break;
  73.             case 'h':
  74.             case 'H':
  75.             n *= 3600; 
  76.             break;
  77.             case 'd': 
  78.             case 'D':
  79.             n *= 86400; 
  80.             break;
  81.             case 'w':
  82.             case 'W':
  83.             n *= 604800;
  84.             break;
  85.             default:
  86.             break;
  87.         }
  88.         return n + parsetime(s+1);
  89.     }
  90.     else return n + parsetime(s);
  91. }
  92.  
  93. extern time_t    time();
  94.  
  95. char *mystrtotime(str)
  96. char    *str;
  97. {
  98.     UTC    utc;
  99.     time_t    newsecs;
  100.     time_t     current;
  101.     char    *retval;
  102.  
  103.     newsecs = parsetime(str);
  104.     time(¤t);
  105.     
  106.     current += newsecs;
  107.         
  108.     utc = time_t2utc(current);
  109.  
  110.     retval = utct2str(utc);
  111.     free((char *) utc);
  112.     return strdup(retval);
  113. }
  114.  
  115. #define MaxCharPerInt 16
  116.  
  117. /* convert integer to string */
  118. char    *itoa(i)
  119. int     i;
  120. {
  121.     char     buf[MaxCharPerInt];
  122.  
  123.     sprintf(buf,"%d",i);
  124.     
  125.     return strdup(buf);
  126.     
  127. }
  128.  
  129. /* convert number to volume */
  130.  
  131. char    *vol2str(vol)
  132. int    vol;
  133. {
  134.     char    buf[BUFSIZ];
  135.     
  136.     num2unit(vol, buf);
  137.     return strdup(buf);
  138. }
  139.  
  140. time_t convert_time(qb)
  141. struct type_UNIV_UTCTime    *qb;
  142. {
  143.     char    *str;
  144.     time_t    temp;
  145.     if (qb == NULL)
  146.         return 0;
  147.     str = qb2str(qb);
  148.     temp = utc2time_t(str2utct(str, strlen(str)));
  149.     free(str);
  150.     return temp;
  151. }
  152.  
  153. char    *time_t2RFC(in)
  154. time_t    in;
  155. {
  156.     char    buf[BUFSIZ];
  157.     struct tm *tm;
  158.     struct UTCtime uts;
  159.     struct timeval dummy;
  160.     struct timezone time_zone;
  161.     
  162.     tm = localtime (&in);
  163.     tm2ut (tm, &uts);
  164.     uts.ut_flags |= UT_ZONE;
  165.     gettimeofday(&dummy, &time_zone);
  166.     uts.ut_zone = time_zone.tz_minuteswest;
  167.     UTC2rfc(&uts, buf);
  168.     return strdup(buf);
  169. }
  170.  
  171.  
  172. /*   */
  173.  
  174. /* reordering of domains and addresses */
  175.  
  176. char    *
  177. reverse_adr(adr)
  178. char    *adr;
  179. {
  180.     extern char    *rindex();
  181.  
  182.     char    *ret = malloc(strlen(adr) + 1), savech;
  183.     char    *ix = adr, *iy = ret, *dom_end, *cix, *last, *dot;
  184.     int    cont;
  185.     while (*ix != '\0') {
  186.         switch (*ix) {
  187.             case '@':
  188.             case '%':
  189.             /* start of domain so reverse */
  190.             *iy++ = *ix++;
  191.             dom_end = ix;
  192.             cont = TRUE;
  193.             while (*dom_end != '\0'
  194.                    && cont == TRUE) {
  195.                 switch(*dom_end) {
  196.                     case ',':
  197.                     case ':':
  198.                     cont = FALSE;
  199.                     break;
  200.                     default:
  201.                     dom_end++;
  202.                     break;
  203.                 }
  204.             }
  205.             /* domain stretches from ix -> dom_end */
  206.  
  207.             last = dom_end;
  208.             while (last != ix) {
  209.                 savech = *last;
  210.                 *last = '\0';
  211.                 if ((dot = rindex(ix, '.')) == NULLCP) {
  212.                     dot = ix;
  213.                     cix =  dot;
  214.                 } else 
  215.                     cix = dot + 1;
  216.                 *last = savech;
  217.                 do 
  218.                 {
  219.                     *iy++ = *cix++;
  220.                 } while (cix != last);
  221.                 
  222.                 if (dot != ix) {
  223.                     *iy++ = '.';
  224.                     last = dot;
  225.                 } else
  226.                     last = ix;
  227.             }
  228.             ix = dom_end;
  229.             break;
  230.                 
  231.             default:            
  232.             *iy++ = *ix++;
  233.             break;
  234.         }
  235.     }
  236.     *iy = '\0';
  237.     return ret;
  238. }
  239.  
  240. char    *
  241. reverse_mta(mta)
  242. char    *mta;
  243. {
  244.     extern    char    *index();
  245.     char *adr, *ret, *ix;
  246.     char    buf[BUFSIZ];
  247.     (void) sprintf(buf, "foo@%s", mta);
  248.     ret = reverse_adr(buf);
  249.     ix = index (ret, '@');
  250.     adr = strdup(++ix);
  251.     free(ret);
  252.     return adr;
  253. }
  254.  
  255. num2unit(num, buf)
  256. int    num;
  257. char    *buf;
  258. {
  259.     int    absolute;
  260.  
  261.     absolute = (num < 0) ? -num : num;
  262.     
  263.     if (absolute > 1000000)
  264.         (void) sprintf(buf, "%s%.2f M", 
  265.                    (num < 0) ? "-" : "",
  266.                    (double) absolute / 1000000.0);
  267.     else if (absolute > 1000)
  268.         (void) sprintf(buf, "%s%.2f k",
  269.                    (num < 0) ? "-" : "",
  270.                    (double) absolute / 1000.0);
  271.     else
  272.         (void) sprintf(buf, "%s%d", 
  273.                    (num < 0) ? "-" : "",
  274.                    absolute);
  275. }
  276.