home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Chans / qmgr-load / qmgr-load.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  6.4 KB  |  293 lines
  1. /* qmgr-load.c: load the queue manager via readqueue */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Chans/qmgr-load/RCS/qmgr-load.c,v 6.0 1991/12/18 20:11:26 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Chans/qmgr-load/RCS/qmgr-load.c,v 6.0 1991/12/18 20:11:26 jpo Rel $
  9.  *
  10.  * $Log: qmgr-load.c,v $
  11.  * Revision 6.0  1991/12/18  20:11:26  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16.  
  17.  
  18. #include "util.h"
  19. #include <pwd.h>
  20. #include "retcode.h"
  21. #include <isode/usr.dirent.h>
  22. #include <sys/stat.h>
  23. #include "Qmgr-ops.h"                   /* operation definitions */
  24. #include "Qmgr-types.h"                 /* type definitions */
  25. #include "ryresponder.h"                /* for generic idempotent responders */
  26.  
  27. /* Sumbit types */
  28. #include "q.h"
  29. #include "prm.h"
  30.  
  31. #define    DEFAULT_MSG_CHUNKS    50
  32.  
  33.  
  34. /* Outside routines */
  35. struct type_Qmgr_MsgStruct      *qstruct2qmgr();
  36. void                            qinit();
  37. CHAN         *mychan = NULLCHAN;
  38. int        msg_chunks;
  39. extern char     *quedfldir;
  40. extern void    rd_end(), sys_init(), err_abrt(), getfpath();
  41. static char *myservice = "qmgr-load";
  42.  
  43. /* OPERATIONS */
  44. static int     op_readqueue();
  45.  
  46. static struct server_dispatch dispatches[] = {
  47.     "readqueue", operation_Qmgr_readqueue, op_readqueue,
  48.     NULL
  49.     };
  50.  
  51. static int get_msg_list();
  52. static struct type_Qmgr_MsgStructList *get_n_messages();
  53. static void dirinit ();
  54. static struct type_Qmgr_MsgStruct *readInMsg();
  55.  
  56. /*   MAIN */
  57.  
  58. /* ARGSUSED */
  59. main (argc, argv, envp)
  60. int     argc;
  61. char    **argv,
  62.     **envp;
  63. {
  64.     register CHAN    **chp;
  65.     sys_init (argv[0]);
  66.     dirinit ();
  67.  
  68.     for (chp = ch_all; 
  69.          *chp != NULLCHAN && (*chp) -> ch_chan_type != CH_QMGR_LOAD;
  70.          chp++)
  71.         continue;
  72.  
  73.     if (*chp != NULLCHAN)
  74.         mychan = *chp;
  75.  
  76.     if (mychan == NULLCHAN
  77.         || mychan->ch_out_info == NULLCP
  78.         || (msg_chunks = atoi(mychan->ch_out_info)) <= 0)
  79.         msg_chunks = DEFAULT_MSG_CHUNKS;
  80.  
  81. #ifdef PP_DEBUG
  82.     if (argc>1 && (strcmp(argv[1],"debug") == 0)) {
  83.         do_debug ();
  84.         exit (0);
  85.     } 
  86. #endif
  87.     ryresponder (argc, argv, PLocalHostName(), myservice, dispatches,
  88.              table_Qmgr_Operations, NULLIFP, NULLIFP); 
  89.     exit (0);       /* NOT REACHED */
  90. }
  91.  
  92. /* routine to move to correct place in file system */
  93. static void dirinit ()
  94. {
  95.     if (chdir (quedfldir) < 0)
  96.         err_abrt (RP_LIO, " Unable to change directory to '%s'",
  97.               quedfldir);
  98. }
  99.  
  100. #ifdef PP_DEBUG
  101. do_debug ()
  102. {
  103.     struct type_Qmgr_MsgStructList *ml, *mp;
  104.     struct type_Qmgr_MsgList *mlp;
  105.  
  106.     mlp = (struct type_Qmgr_MsgList *) smalloc (sizeof *mlp);
  107.     mlp -> deleted = NULL;
  108.  
  109.     printf ("start load\n");
  110.     while ((ml = get_n_messages (msg_chunks)) != NULL) {
  111.         mlp -> msgs = ml;
  112.  
  113.         printf ("\tstart batch\n");
  114.         for (mp = ml; mp; mp = mp -> next) {
  115.             char *p = qb2str(mp -> MsgStruct ->
  116.                      messageinfo -> queueid);
  117.             printf ("\t\tload %s\n", p);
  118.             free (p);
  119.         }
  120.         printf ("\tend batch\n");
  121.         free_Qmgr_MsgList (mlp);
  122.         mlp = (struct type_Qmgr_MsgList *) smalloc (sizeof *mlp);
  123.         mlp -> deleted = NULL;
  124.     }
  125.     printf ("end load\n");
  126. }
  127. #endif
  128.  
  129.  
  130. /*   OPERATIONS */
  131.  
  132. /* ARGSUSED */
  133. static int op_readqueue (ad, ryo, rox, in, roi)
  134. int                     ad;
  135. struct RyOperation      *ryo;
  136. struct RoSAPinvoke      *rox;
  137. caddr_t                 in;
  138. struct RoSAPindication  *roi;
  139. {
  140.     if (rox->rox_nolinked == 0) {
  141.         PP_LOG (LLOG_NOTICE,
  142.             ("RO-INVOKE.INDICATION/%d: %s, unknown linkage %d",
  143.             ad, ryo->ryo_name, rox->rox_linkid));
  144.         return ureject (ad, ROS_IP_LINKED, rox, roi);
  145.     }
  146.     PP_LOG (LLOG_NOTICE,
  147.         ("RO-INVOKE.INDICATION/%d: %s",ad, ryo -> ryo_name));
  148.     return get_msg_list(ad, rox, roi);
  149. }
  150.  
  151. static int get_msg_list(ad, rox, roi)
  152. int                     ad;
  153. struct RoSAPinvoke      *rox;
  154. struct RoSAPindication  *roi;
  155. {
  156.     struct type_Qmgr_MsgList *base;
  157.  
  158.     PP_TRACE(("get_msg_list ()"));
  159.  
  160.     if ((base = (struct type_Qmgr_MsgList *) calloc (1, sizeof(*base)))
  161.          == NULL)
  162.         return error (ad, error_Qmgr_congested, (caddr_t) NULL,
  163.                   rox, roi);
  164.  
  165.     /* now make list */
  166.     if ((base->msgs = get_n_messages(msg_chunks)) == 
  167.         (struct type_Qmgr_MsgStructList *) NOTOK) {
  168.         base->msgs = NULL;
  169.         return error (ad, error_Qmgr_congested, (caddr_t) NULL,
  170.                   rox, roi);
  171.     }
  172.  
  173.     if (RyDsResult (ad, rox->rox_id, (caddr_t) base, ROS_NOPRIO, roi)
  174.         == NOTOK)
  175.         ros_adios(&roi->roi_preject,"RESULT");
  176.     free_Qmgr_MsgList (base);
  177.     return OK;
  178. }
  179.  
  180. #define SIZE_INCR 1000
  181. static int    count = 0, noEntries = 0, maxnumb = 0;
  182. static char    **msgs = NULLVP;
  183.  
  184. static struct type_Qmgr_MsgStructList *get_n_messages(num)
  185. int    num;
  186. {
  187.     struct type_Qmgr_MsgStructList *head, *tail, *temp;
  188.     struct type_Qmgr_MsgStruct *msg;
  189.     extern char *quedfldir;
  190.     int i;
  191.  
  192.     head = tail = NULL;
  193.     
  194.     if (noEntries > 0 && count == noEntries) {
  195.         return head;
  196.     }
  197.  
  198.     if (noEntries == 0) {
  199.         if (msgs) {
  200.             free_hier(msgs, noEntries);
  201.             msgs = NULLVP;
  202.         }
  203.         maxnumb = 0;
  204.         hier_scanQ (quedfldir, NULLCP, 
  205.                 &noEntries, &msgs, 
  206.                 &maxnumb, NULLIFP);
  207.         count = 0;
  208.     }
  209.  
  210.     i = 0;
  211.     while (count < noEntries && i < num) {
  212.         PP_TRACE (("reading message %s", msgs[count]));
  213.         if ((msg = readInMsg(msgs[count++])) != NULL) {
  214.             /* add to list */
  215.             temp = (struct type_Qmgr_MsgStructList *) 
  216.                 calloc(1,sizeof(*temp));
  217.             temp->MsgStruct = msg;
  218.             if (head == NULL)
  219.                 head = tail = temp;
  220.             else {
  221.                 tail->next = temp;
  222.                 tail = temp;
  223.             }
  224.             i++;
  225.         }
  226.     }
  227.     return head;
  228. }
  229.  
  230. static struct type_Qmgr_MsgStruct *readInMsg(name)
  231. char *name;
  232. {
  233.     struct type_Qmgr_MsgStruct *arg = NULL;
  234.     struct prm_vars prm;
  235.     Q_struct        que;
  236.     ADDR            *sender = NULL;
  237.     ADDR            *recips = NULL;
  238.     int             rcount, result;
  239.  
  240.     result = OK;
  241.  
  242.     prm_init (&prm);
  243.     q_init (&que);
  244.     qinit (&que);
  245.  
  246.     if ((result == OK)
  247.         && (rp_isbad(rd_msg(name,&prm,&que,&sender,&recips,&rcount)))) {
  248.         PP_LOG(LLOG_EXCEPTIONS,
  249.                ("Chans/qmgr-load rd_msg err: '%s'",name));
  250.         result = NOTOK;
  251.     }
  252.     /* unlock message */
  253.     rd_end();
  254.  
  255.     if ((result == OK)
  256.         && ((arg = qstruct2qmgr(name,&prm,&que,sender,recips,rcount)) == NULL)) {
  257.         PP_LOG(LLOG_EXCEPTIONS,
  258.                ("Chans/qmgr-load qstruct2qmgr err: '%s'",name));
  259.         result = NOTOK;
  260.     }
  261.  
  262.     /* free all storage */
  263.     q_free (&que);
  264.  
  265.     return result == NOTOK ? NULL : arg;
  266. }
  267.  
  268.  
  269. /*    ERROR */
  270.  
  271. int  error (sd, err, param, rox, roi)
  272. int     sd,
  273.     err;
  274. caddr_t param;
  275. struct RoSAPinvoke *rox;
  276. struct RoSAPindication *roi;
  277. {
  278.     if (RyDsError (sd, rox -> rox_id, err, param, ROS_NOPRIO, roi) == NOTOK)
  279.         ros_adios (&roi -> roi_preject, "ERROR");
  280.  
  281.     return OK;
  282. }
  283.  
  284. int ureject (sd, reason, rox, roi)
  285. int     sd, reason;
  286. struct RoSAPinvoke *rox;
  287. struct RoSAPindication *roi;
  288. {
  289.     if ( RyDsUReject (sd, rox -> rox_id, reason, ROS_NOPRIO, roi) == NOTOK)
  290.         ros_adios (&roi -> roi_preject, "U-REJECT");
  291.     return OK;
  292. }
  293.