home *** CD-ROM | disk | FTP | other *** search
/ vsiftp.vmssoftware.com / VSIPUBLIC@vsiftp.vmssoftware.com.tar / FREEWARE / FREEWARE40.ZIP / callmon / src / callmon$util.c < prev    next >
C/C++ Source or Header  |  1996-08-06  |  7KB  |  275 lines
  1. /*  CALLMON - A Call Monitor for OpenVMS Alpha
  2.  *
  3.  *  File:     CALLMON$UTIL.C
  4.  *  Author:   Thierry Lelegard
  5.  *  Version:  1.0
  6.  *  Date:     24-JUL-1996
  7.  *
  8.  *  Abstract: CALLMON Utility Routines.
  9.  */
  10.  
  11.  
  12. #include "callmon$private.h"
  13.  
  14.  
  15. /*******************************************************************************
  16.  *
  17.  *  This routine allocates memory. Exit application in case of error.
  18.  */
  19.  
  20. void* callmon$$alloc (size_t size)
  21. {
  22.     void* ptr;
  23.     int32 alloc_size = size;
  24.     uint32 status = lib$get_vm (&alloc_size, &ptr);
  25.  
  26.     if (!$VMS_STATUS_SUCCESS (status)) {
  27.         callmon$$putmsg (CALLMON$_GETVM, 1, alloc_size, status);
  28.         sys$exit (status | STS$M_INHIB_MSG);
  29.     }
  30.  
  31.     return ptr;
  32. }
  33.  
  34.  
  35. /*******************************************************************************
  36.  *
  37.  *  This routine frees memory previously allocated by callmon$$alloc.
  38.  *  Returns a status code.
  39.  */
  40.  
  41. uint32 callmon$$free (void* ptr, size_t size)
  42. {
  43.     int32 alloc_size = size;
  44.     return lib$free_vm (&alloc_size, &ptr);
  45. }
  46.  
  47.  
  48. /*******************************************************************************
  49.  *
  50.  *  This routine prints a status array using a variable argument list.
  51.  */
  52.  
  53. void callmon$$putmsg (uint32 status, ...)
  54. {
  55.     int count;
  56.     va_list ap;
  57.     uint32 vector [MAX_ARG + 1];
  58.     uint32* v = vector;
  59.  
  60.     va_count (count);
  61.     if (count > MAX_ARG)
  62.         count = MAX_ARG;
  63.  
  64.     if (count > 0) {
  65.         *v++ = count;
  66.         *v++ = status;
  67.         va_start (ap, status);
  68.         while (--count > 0)
  69.             *v++ = va_arg (ap, uint32);
  70.         va_end (ap);
  71.         sys$putmsg (vector, 0, 0, 0);
  72.     }
  73. }
  74.  
  75.  
  76. /*******************************************************************************
  77.  *
  78.  *  This routine returns the number of translations of a logical name.
  79.  *  If table is NULL, LNM$FILE_DEV is used.
  80.  *  In case of error, returns zero.
  81.  */
  82.  
  83. int callmon$$translation_count (char* name, char* table)
  84. {
  85.     uint32 status;
  86.     int32 max_index;
  87.     desc_t name_d, table_d;
  88.     item_t* itm;
  89.     item_t itmlst [5];
  90.  
  91.     set_str_desc (&name_d, name);
  92.     set_str_desc (&table_d, table != NULL ? table : "LNM$FILE_DEV");
  93.  
  94.     itm = itmlst;
  95.     set_data_item (itm++, LNM$_MAX_INDEX, max_index);
  96.     set_final_item (itm++);
  97.  
  98.     status = sys$trnlnm (0, &table_d, &name_d, 0, itmlst);
  99.  
  100.     return $VMS_STATUS_SUCCESS (status) ? max_index + 1 : 0;
  101. }
  102.  
  103.  
  104. /*******************************************************************************
  105.  *
  106.  *  This routine translates a logical name.
  107.  *  If table is NULL, LNM$FILE_DEV is used.
  108.  *  In case of error, returns a status code and set value to "".
  109.  */
  110.  
  111. uint32 callmon$$translate (
  112.     char*  name,
  113.     char*  value,
  114.     size_t size,
  115.     char*  table,
  116.     int    index)
  117. {
  118.     uint32 status;
  119.     uint16 length;
  120.     uint32 index_val;
  121.     desc_t name_d, table_d;
  122.     item_t* itm;
  123.     item_t itmlst [5];
  124.  
  125.     set_str_desc (&name_d, name);
  126.     set_str_desc (&table_d, table != NULL ? table : "LNM$FILE_DEV");
  127.     index_val = index;
  128.  
  129.     itm = itmlst;
  130.     set_data_item (itm++, LNM$_INDEX, index_val);
  131.     set_item (itm++, LNM$_STRING, value, size - 1, &length);
  132.     set_final_item (itm++);
  133.  
  134.     status = sys$trnlnm (0, &table_d, &name_d, 0, itmlst);
  135.  
  136.     value [$VMS_STATUS_SUCCESS (status) ? length : 0] = '\0';
  137.  
  138.     return status;
  139. }
  140.  
  141.  
  142. /*******************************************************************************
  143.  *
  144.  *  This routine translates a search list and return an allocated
  145.  *  array of nul-terminated string. The end of the pointer array
  146.  *  is NULL.
  147.  */
  148.  
  149. char** callmon$$search_list (char* name, char* table)
  150. {
  151.     uint32 status;
  152.     int count;
  153.     int index;
  154.     char* i_table;
  155.     char** list;
  156.     char value [256];
  157.  
  158.     if ((count = callmon$$translation_count (name, table)) <= 0)
  159.         return NULL;
  160.  
  161.     list = callmon$$alloc ((count + 1) * sizeof (char*));
  162.  
  163.     for (index = 0; index < count; index++) {
  164.  
  165.         status = callmon$$translate (name, value, sizeof (value), table, index);
  166.  
  167.         if (!$VMS_STATUS_SUCCESS (status))
  168.             list [index] = "";
  169.         else {
  170.             list [index] = callmon$$alloc (strlen (value) + 1);
  171.             strcpy (list [index], value);
  172.         }
  173.     }
  174.  
  175.     list [count] = NULL;
  176.     return list;
  177. }
  178.  
  179.  
  180. /*******************************************************************************
  181.  *
  182.  *  This routine returns the page size of the system.
  183.  *  Exit image on error (should not occur...).
  184.  */
  185.  
  186. uint32 callmon$$page_size (void)
  187. {
  188.     uint32 status;
  189.     uint32 size;
  190.     iosb_t iosb;
  191.     item_t itmlst [5];
  192.     item_t* itm = itmlst;
  193.  
  194.     set_data_item (itm++, SYI$_PAGE_SIZE, size);
  195.     set_final_item (itm++);
  196.  
  197.     status = sys$getsyiw (0, 0, 0, itmlst, &iosb, 0, 0);
  198.  
  199.     if ($VMS_STATUS_SUCCESS (status))
  200.         status = iosb.status;
  201.     if (!$VMS_STATUS_SUCCESS (status)) {
  202.         callmon$$putmsg (CALLMON$_GETSYI, 0, status);
  203.         sys$exit (status | STS$M_INHIB_MSG);
  204.     }
  205.  
  206.     return size;
  207. }
  208.  
  209.  
  210. /*******************************************************************************
  211.  *
  212.  *  This routine is an "allocation routine" for LIB$INSERT_TREE on any
  213.  *  kind of tree. It assumes that the structure has already been allocated
  214.  *  and initialized by the caller. The address of the pre-allocated structure
  215.  *  must be passed in the user_data argument.
  216.  */
  217.  
  218. uint32 callmon$$tree_allocate_from_user_data (
  219.     void*  symbol,
  220.     void** node,
  221.     void*  user_data)
  222. {
  223.     *node = user_data;
  224.     return SS$_NORMAL;
  225. }
  226.  
  227.  
  228. /*******************************************************************************
  229.  *
  230.  *  This routine looks up a name/value table and search the specified name.
  231.  *  If the name is found, its value is returned, otherwise return the
  232.  *  default value. The last element of the table must have a NULL name.
  233.  */
  234.  
  235. int32 callmon$$name_to_value (name_value_t* table, char* name, int32 defvalue)
  236. {
  237.     name_value_t* p;
  238.  
  239.     for (p = table; p->name != NULL; p++)
  240.         if (strcmp (name, p->name) == 0)
  241.             return p->value;
  242.  
  243.     return defvalue;
  244. }
  245.  
  246.  
  247. /*******************************************************************************
  248.  *
  249.  *  This routine disables any kind of threading and saves the previous state.
  250.  */
  251.  
  252. uint32 callmon$$disable_threading (thread_state_t* state)
  253. {
  254.     /* Disable AST delivery and save previous state */
  255.  
  256.     state->ast_state = sys$setast (0);
  257.  
  258.     /* After OpenVMS V7.0, should also disable upcalls and kernel threads.
  259.      * But I don't know how to do that... */
  260.      
  261.     return SS$_NORMAL;
  262. }
  263.  
  264.  
  265. /*******************************************************************************
  266.  *
  267.  *  This routine restores the previous threading state.
  268.  */
  269.  
  270. uint32 callmon$$restore_threading (thread_state_t* state)
  271. {
  272.     sys$setast (state->ast_state == SS$_WASSET ? 1 : 0);
  273.     return SS$_NORMAL;
  274. }
  275.