home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume21 / amd / part05 / amq_subr.c < prev    next >
C/C++ Source or Header  |  1990-04-10  |  7KB  |  358 lines
  1. /*
  2.  * $Id: amq_subr.c,v 5.1.1.1 90/01/11 17:03:40 jsp Exp Locker: jsp $
  3.  *
  4.  * Copyright (c) 1990 Jan-Simon Pendry
  5.  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
  6.  * Copyright (c) 1990 The Regents of the University of California.
  7.  * All rights reserved.
  8.  *
  9.  * This code is derived from software contributed to Berkeley by
  10.  * Jan-Simon Pendry at Imperial College, London.
  11.  *
  12.  * Redistribution and use in source and binary forms are permitted
  13.  * provided that the above copyright notice and this paragraph are
  14.  * duplicated in all such forms and that any documentation,
  15.  * advertising materials, and other materials related to such
  16.  * distribution and use acknowledge that the software was developed
  17.  * by Imperial College of Science, Technology and Medicine, London, UK.
  18.  * The names of the College and University may not be used to endorse
  19.  * or promote products derived from this software without specific
  20.  * prior written permission.
  21.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  22.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  23.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  24.  *
  25.  *    %W% (Berkeley) %G%
  26.  */
  27. /*
  28.  * Auxilliary routines for amq tool
  29.  */
  30.  
  31. #include "am.h"
  32. #include "amq.h"
  33.  
  34. #include <sys/param.h>
  35.  
  36. /*ARGSUSED*/
  37. voidp
  38. amqproc_null_1(argp, rqstp)
  39. voidp argp;
  40. struct svc_req *rqstp;
  41. {
  42.     static char res;
  43.  
  44.     return (voidp) &res;
  45. }
  46.  
  47. /*
  48.  * Return a sub-tree of mounts
  49.  */
  50. /*ARGSUSED*/
  51. amq_mount_tree_p *
  52. amqproc_mnttree_1(argp, rqstp)
  53. voidp argp;
  54. struct svc_req *rqstp;
  55. {
  56.     static am_node *mp;
  57.     mp = find_ap(*(char **) argp);
  58.     return (amq_mount_tree_p *) ∓
  59. }
  60.  
  61. /*
  62.  * Unmount a single node
  63.  */
  64. /*ARGSUSED*/
  65. voidp
  66. amqproc_umnt_1(argp, rqstp)
  67. voidp argp;
  68. struct svc_req *rqstp;
  69. {
  70.     static char res;
  71.     am_node *mp = find_ap(*(char **) argp);
  72.     if (mp)
  73.         forcibly_timeout_mp(mp);
  74.  
  75.     return (voidp) &res;
  76. }
  77.  
  78. /*
  79.  * Return global statistics
  80.  */
  81. /*ARGSUSED*/
  82. amq_mount_stats *
  83. amqproc_stats_1(argp, rqstp)
  84. voidp argp;
  85. struct svc_req *rqstp;
  86. {
  87.     return (amq_mount_stats *) &amd_stats;
  88. }
  89.  
  90. /*
  91.  * Return the entire tree of mount nodes
  92.  */
  93. /*ARGSUSED*/
  94. amq_mount_tree_list *
  95. amqproc_export_1(argp, rqstp)
  96. voidp argp;
  97. struct svc_req *rqstp;
  98. {
  99.     static amq_mount_tree_list aml;
  100.  
  101. #ifdef oldcode
  102.     static am_node **mvec;
  103.     int i;
  104.     int n = 0;
  105.  
  106.     mvec = (struct am_node **)
  107.         xrealloc(mvec, (1+last_used_map) * sizeof(am_node *));
  108.     for (i = last_used_map; i >= 0; --i) {
  109.         am_node *mp = exported_ap[i];
  110.         if (mp && (mp->am_flags & AMF_ROOT))
  111.             mvec[n++] = mp;
  112.     }
  113.  
  114.     aml.amq_mount_tree_list_val = (amq_mount_tree_p *) mvec;
  115.     aml.amq_mount_tree_list_len = n;
  116. #else
  117.     aml.amq_mount_tree_list_val = (amq_mount_tree_p *) &exported_ap[0];
  118.     aml.amq_mount_tree_list_len = 1;    /* XXX */
  119. #endif
  120.     return &aml;
  121. }
  122.  
  123. int *
  124. amqproc_setopt_1(argp, rqstp)
  125. voidp argp;
  126. struct svc_req *rqstp;
  127. {
  128.     static int rc;
  129.  
  130.     amq_setopt *opt = (amq_setopt *) argp;
  131.  
  132.     rc = 0;
  133.     switch (opt->as_opt) {
  134.     case AMOPT_DEBUG:
  135. #ifdef DEBUG
  136.         if (debug_option(opt->as_str))
  137.             rc = EINVAL;
  138. #else
  139.         rc = EINVAL;
  140. #endif
  141.         break;
  142.  
  143.     case AMOPT_LOGFILE:
  144. #ifdef not_yet
  145.         if (switch_to_logfile(opt->as_str))
  146.             rc = EINVAL;
  147. #else
  148.         rc = EACCES;
  149. #endif
  150.         break;
  151.  
  152.     case AMOPT_XLOG:
  153.         if (switch_option(opt->as_str))
  154.             rc = EINVAL;
  155.         break;
  156.  
  157.     case AMOPT_FLUSHMAPC:
  158.         if (amd_state == Run) {
  159.             plog(XLOG_INFO, "amq says flush cache");
  160.             do_mapc_reload = 0;
  161.         }
  162.         break;
  163.     }
  164.     return &rc;
  165. }
  166.  
  167. amq_mount_info_list *
  168. amqproc_getmntfs_1(argp, rqstp)
  169. voidp argp;
  170. struct svc_req *rqstp;
  171. {
  172. extern qelem mfhead;
  173.     return (amq_mount_info_list *) &mfhead;    /* XXX */
  174. }
  175.  
  176. /*
  177.  * XDR routines.
  178.  */
  179. bool_t
  180. xdr_amq_string(xdrs, objp)
  181.     XDR *xdrs;
  182.     amq_string *objp;
  183. {
  184.     if (!xdr_string(xdrs, objp, AMQ_STRLEN)) {
  185.         return (FALSE);
  186.     }
  187.     return (TRUE);
  188. }
  189.  
  190. bool_t
  191. xdr_amq_setopt(xdrs, objp)
  192.     XDR *xdrs;
  193.     amq_setopt *objp;
  194. {
  195.     if (!xdr_enum(xdrs, (enum_t *)&objp->as_opt)) {
  196.         return (FALSE);
  197.     }
  198.     if (!xdr_string(xdrs, &objp->as_str, AMQ_STRLEN)) {
  199.         return (FALSE);
  200.     }
  201.     return (TRUE);
  202. }
  203.  
  204. /*
  205.  * More XDR routines  - Should be used for OUTPUT ONLY.
  206.  */
  207. bool_t
  208. xdr_amq_mount_tree(xdrs, objp)
  209.     XDR *xdrs;
  210.     amq_mount_tree *objp;
  211. {
  212.     am_node *mp = (am_node *) objp;
  213.  
  214.     if (!xdr_amq_string(xdrs, &mp->am_mnt->mf_info)) {
  215.         return (FALSE);
  216.     }
  217.     if (!xdr_amq_string(xdrs, &mp->am_path)) {
  218.         return (FALSE);
  219.     }
  220.     if (!xdr_amq_string(xdrs, mp->am_link ? &mp->am_link : &mp->am_mnt->mf_mount)) {
  221.         return (FALSE);
  222.     }
  223.     if (!xdr_amq_string(xdrs, &mp->am_mnt->mf_ops->fs_type)) {
  224.         return (FALSE);
  225.     }
  226.     if (!xdr_long(xdrs, &mp->am_stats.s_mtime)) {
  227.         return (FALSE);
  228.     }
  229.     if (!xdr_u_short(xdrs, &mp->am_stats.s_uid)) {
  230.         return (FALSE);
  231.     }
  232.     if (!xdr_int(xdrs, &mp->am_stats.s_getattr)) {
  233.         return (FALSE);
  234.     }
  235.     if (!xdr_int(xdrs, &mp->am_stats.s_lookup)) {
  236.         return (FALSE);
  237.     }
  238.     if (!xdr_int(xdrs, &mp->am_stats.s_readdir)) {
  239.         return (FALSE);
  240.     }
  241.     if (!xdr_int(xdrs, &mp->am_stats.s_readlink)) {
  242.         return (FALSE);
  243.     }
  244.     if (!xdr_int(xdrs, &mp->am_stats.s_statfs)) {
  245.         return (FALSE);
  246.     }
  247.     if (!xdr_pointer(xdrs, (char **)&mp->am_osib, sizeof(amq_mount_tree), xdr_amq_mount_tree)) {
  248.         return (FALSE);
  249.     }
  250.     if (!xdr_pointer(xdrs, (char **)&mp->am_child, sizeof(amq_mount_tree), xdr_amq_mount_tree)) {
  251.         return (FALSE);
  252.     }
  253.     return (TRUE);
  254. }
  255.  
  256. bool_t
  257. xdr_amq_mount_tree_p(xdrs, objp)
  258.     XDR *xdrs;
  259.     amq_mount_tree_p *objp;
  260. {
  261.     if (!xdr_pointer(xdrs, (char **)objp, sizeof(amq_mount_tree), xdr_amq_mount_tree)) {
  262.         return (FALSE);
  263.     }
  264.     return (TRUE);
  265. }
  266.  
  267.  
  268. bool_t
  269. xdr_amq_mount_stats(xdrs, objp)
  270.     XDR *xdrs;
  271.     amq_mount_stats *objp;
  272. {
  273.     if (!xdr_int(xdrs, &objp->as_drops)) {
  274.         return (FALSE);
  275.     }
  276.     if (!xdr_int(xdrs, &objp->as_stale)) {
  277.         return (FALSE);
  278.     }
  279.     if (!xdr_int(xdrs, &objp->as_mok)) {
  280.         return (FALSE);
  281.     }
  282.     if (!xdr_int(xdrs, &objp->as_merr)) {
  283.         return (FALSE);
  284.     }
  285.     if (!xdr_int(xdrs, &objp->as_uerr)) {
  286.         return (FALSE);
  287.     }
  288.     return (TRUE);
  289. }
  290.  
  291.  
  292. bool_t
  293. xdr_amq_mount_tree_list(xdrs, objp)
  294.     XDR *xdrs;
  295.     amq_mount_tree_list *objp;
  296. {
  297.      if (!xdr_array(xdrs, (char **)&objp->amq_mount_tree_list_val, (u_int *)&objp->amq_mount_tree_list_len, ~0, sizeof(amq_mount_tree_p), xdr_amq_mount_tree_p)) {
  298.         return (FALSE);
  299.     }
  300.     return (TRUE);
  301. }
  302.  
  303. xdr_amq_mount_info_qelem(xdrs, qhead)
  304.     XDR *xdrs;
  305.     qelem *qhead;
  306. {
  307.     /*
  308.      * Compute length of list
  309.      */
  310.     mntfs *mf;
  311.     u_int len = 0;
  312.     for (mf = LAST(mntfs, qhead); mf != HEAD(mntfs, qhead); mf = PREV(mntfs, mf)) {
  313.         if (!(mf->mf_ops->fs_flags & FS_AMQINFO))
  314.             continue;
  315.         len++;
  316.     }
  317.     xdr_u_int(xdrs, &len);
  318.  
  319.     /*
  320.      * Send individual data items
  321.      */
  322.     for (mf = LAST(mntfs, qhead); mf != HEAD(mntfs, qhead); mf = PREV(mntfs, mf)) {
  323.         int up;
  324.         if (!(mf->mf_ops->fs_flags & FS_AMQINFO))
  325.             continue;
  326.  
  327.         if (!xdr_amq_string(xdrs, &mf->mf_ops->fs_type)) {
  328.             return (FALSE);
  329.         }
  330.         if (!xdr_amq_string(xdrs, &mf->mf_mount)) {
  331.             return (FALSE);
  332.         }
  333.         if (!xdr_amq_string(xdrs, &mf->mf_info)) {
  334.             return (FALSE);
  335.         }
  336.         if (!xdr_amq_string(xdrs, &mf->mf_server->fs_host)) {
  337.             return (FALSE);
  338.         }
  339.         if (!xdr_int(xdrs, &mf->mf_error)) {
  340.             return (FALSE);
  341.         }
  342.         if (!xdr_int(xdrs, &mf->mf_refc)) {
  343.             return (FALSE);
  344.         }
  345.         if (mf->mf_server->fs_flags & FSF_ERROR)
  346.             up = 0;
  347.         else switch (mf->mf_server->fs_flags & (FSF_DOWN|FSF_VALID)) {
  348.         case FSF_DOWN|FSF_VALID: up = 0; break;
  349.         case FSF_VALID: up = 1; break;
  350.         default: up = -1; break;
  351.         }
  352.         if (!xdr_int(xdrs, &up)) {
  353.             return (FALSE);
  354.         }
  355.     }
  356.     return (TRUE);
  357. }
  358.