src/venus/cacheout.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afs/vldbint.h>
  11
  12 #include <afsconfig.h>
  13 #include <afs/param.h>
  14
  15 RCSID
  16     ("$Header$");
  17
  18 #include <stdio.h>
  19 #include <string.h>
  20
  21 #ifdef  AFS_AIX32_ENV
  22 #include <signal.h>
  23 #endif
  24
  25 #include <ctype.h>
  26 #include <sys/types.h>
  27 #include <afs/cmd.h>
  28 #include <afs/cellconfig.h>
  29 #include <rx/rx.h>
  30 #include <rx/xdr.h>
  31
  32 #include <ubik.h>
  33 #include <afs/kauth.h>
  34 #include <afs/afsutil.h>
  35
  36 /*
  37 File servers in NW byte order.
  38 */
  39
  40 int server_count = 0;
  41 afs_int32 server_id[256];
  42
  43 struct ubik_client *client;
  44
  45 struct ViceIds {
  46     int ViceIds_len;
  47     afs_int32 *ViceIds_val;
  48 };
  49
  50 struct IPAddrs {
  51     int IPAddrs_len;
  52     afs_int32 *IPAddrs_val;
  53 };
  54
  55 struct ubik_dbase *VL_dbase;
  56 struct afsconf_dir *vldb_confdir;
  57 struct kadstats dynamic_statistics;
  58 struct rx_securityClass *junk;
  59
  60 #include <sys/socket.h>
  61 #include <netinet/in.h>
  62 #include <arpa/inet.h>
  63
  64 extern int VL_GetAddrs();
  65
  66 afs_int32
  67 InvalidateCache(as)
  68      struct cmd_syndesc *as;
  69 {
  70     afs_int32 code = 0;
  71     struct cmd_item *u;
  72     struct rx_connection *conn;
  73     int i;
  74     afs_int32 port = 7000;
  75
  76     afs_int32 spare1 = 0;
  77     afs_int32 spare2, spare3;
  78
  79     afs_int32 id[256];
  80     afs_int32 ip[256];
  81
  82     struct ViceIds vid;
  83     struct IPAddrs ipa;
  84
  85     code = ListServers();
  86     if (code)
  87         return code;
  88
  89
  90     /* make sure something there */
  91
  92     if (!as->parms[0].items && !as->parms[1].items) {
  93         printf("Use -help flag for list of optional argmuments\n");
  94         return 1;
  95     }
  96
  97     /* get user ids */
  98
  99     for (i = 0, u = as->parms[0].items; i < 255 && u; ++i, u = u->next) {
 100         code = util_GetInt32(u->data, &id[i]);
 101         if (code) {
 102             printf("Fatal error: bad conversion to long for %s\n", u->data);
 103             return code;
 104         }
 105     }
 106
 107     id[i] = 0;
 108     vid.ViceIds_len = i;
 109     vid.ViceIds_val = id;
 110
 111     /* get IP addresses, convert to NW byte order */
 112
 113     for (i = 0, u = as->parms[1].items; i < 255 && u; ++i, u = u->next)
 114         ip[i] = inet_addr(u->data);
 115
 116     ip[i] = 0;
 117     ipa.IPAddrs_len = i;
 118     ipa.IPAddrs_val = ip;
 119
 120     for (i = 0; i < server_count; ++i) {
 121         conn = rx_NewConnection(server_id[i], htonl(port), 1, junk, 0);
 122         if (!conn) {
 123             printf("Informational: could not connect to \
 124 file server %lx\n", server_id[i]);
 125             continue;
 126         }
 127
 128         /* invalidate the cache */
 129
 130         code = RXAFS_FlushCPS(conn, &vid, &ipa, spare1, &spare2, &spare3);
 131
 132         /*
 133          * May get spurious error codes in case server is
 134          * down or is reported by VLDB as a file server
 135          * even though it is not configured as such in the
 136          * cell.
 137          */
 138
 139         if (code)
 140             printf("Informational: failed to invalidate \
 141 file server %lx cache code = %ld\n", server_id[i], code);
 142
 143         rx_DestroyConnection(conn);
 144     }
 145     return 0;
 146 }
 147
 148 /*
 149 Obtain list of file servers as known to VLDB. These may
 150 not actually be configured as file servers in the cell.
 151 */
 152
 153 afs_int32
 154 ListServers()
 155 {
 156     afs_int32 code;
 157     struct rx_connection *conn;
 158     struct rx_call *call;
 159     int i;
 160     int byte_count;
 161     int nentries;
 162     afs_int32 base, index;
 163
 164     afs_int32 Handle = 0;
 165     afs_int32 spare2 = 0;
 166     struct VLCallBack spare3;
 167
 168     bulkaddrs addrs, m_addrs;
 169     ListAddrByAttributes m_attrs;
 170     afs_int32 m_unique, m_nentries;
 171     afs_uint32 *p;
 172
 173     /* get list of file servers in NW byte order */
 174     memset(&addrs, 0, sizeof(addrs));
 175     memset(&spare3, 0, sizeof(spare3));
 176     code =
 177         ubik_Call(VL_GetAddrs, client, 0, Handle, spare2, &spare3,
 178                   &server_count, &addrs);
 179     if (code) {
 180         printf("Fatal error: could not get list of file servers\n");
 181         return 1;
 182     }
 183
 184     for (i = 0, p = addrs.bulkaddrs_val; i < server_count; ++i, ++p) {
 185         if (((*p & 0xff000000) == 0xff000000) && ((*p) & 0xffff)) {
 186             if ((base >= 0) && (base <= VL_MAX_ADDREXTBLKS) && (index >= 1)
 187                 && (index <= VL_MHSRV_PERBLK)) {
 188                 m_attrs.Mask = VLADDR_INDEX;
 189                 m_attrs.index = (base * VL_MHSRV_PERBLK) + index;
 190                 m_nentries = 0;
 191                 m_addrs.bulkaddrs_val = 0;
 192                 m_addrs.bulkaddrs_len = 0;
 193                 code =
 194                     ubik_Call(VL_GetAddrsU, client, 0, &m_attrs, &m_uuid,
 195                               &m_unique, &m_nentries, &m_addrs);
 196                 if (vcode)
 197                     return code;
 198
 199                 m_addrp = (afs_int32 *) m_addrs.bulkaddrs_val;
 200                 for (j = 0; j < m_nentries; j++, m_addrp++) {
 201                     server_id[i] = *m_addrp;
 202                     *m_addrp = htonl(*m_addrp);
 203                     printf("host %s\n", hostutil_GetNameByINet(*p));
 204                 }
 205             }
 206         } else {
 207             server_id[i] = *p;
 208             *p = htonl(*p);
 209             printf("host %s\n", hostutil_GetNameByINet(*p));
 210         }
 211     }
 212     return code;
 213 }
 214
 215 afs_int32
 216 GetServerList()
 217 {
 218     afs_int32 code;
 219     int i;
 220
 221     code = ListServers();
 222     if (code)
 223         return (code);
 224
 225     printf("There are %d file servers in the cell\n\n", server_count);
 226     fflush(stdout);
 227     for (i = 0; i < server_count; ++i)
 228         printf("%s\n", hostutil_GetNameByINet(server_id[i]));
 229     fflush(stdout);
 230
 231     return code;
 232 }
 233
 234 /*
 235 User enters lists of:
 236
 237         1. AFS user ids - say from "pts exam username".
 238         2. IP addresses - say from /etc/hosts (no wildcards).
 239
 240 Command is executed in user's cell.
 241 */
 242
 243 static
 244 MyBeforeProc(as, arock)
 245      struct cmd_syndesc *as;
 246      char *arock;
 247 {
 248     register char *tcell = NULL;
 249     char confdir[200];
 250     struct afsconf_dir *tdir;
 251     struct afsconf_cell info;
 252     struct rx_connection *serverconns[MAXSERVERS];
 253     register afs_int32 code, i;
 254     register afs_int32 sauth;
 255
 256     sprintf(confdir, "%s", AFSDIR_CLIENT_ETC_DIRPATH);
 257     /* setup to talk to servers */
 258     code = rx_Init(0);
 259     if (code)
 260         printf("Warning: could not initialize network communication.\n");
 261
 262     junk = rxnull_NewClientSecurityObject();
 263     tdir = afsconf_Open(confdir);
 264     if (!tdir)
 265         printf("Warning: could not get cell configuration.\n");
 266
 267     if (as->parms[2].items)     /* if -cell specified */
 268         tcell = as->parms[2].items->data;
 269     code = afsconf_GetCellInfo(tdir, tcell, AFSCONF_VLDBSERVICE, &info);
 270     if (info.numServers > MAXSERVERS)
 271         printf("Warning: could not init cell info.\n");
 272
 273     for (i = 0; i < info.numServers; ++i)
 274         serverconns[i] =
 275             rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
 276                              info.hostAddr[i].sin_port, USER_SERVICE_ID, junk,
 277                              0);
 278     for (; i < MAXSERVERS; ++i) {
 279         serverconns[i] = (struct rx_connection *)0;
 280     }
 281     code = ubik_ClientInit(serverconns, &client);
 282     if (code)
 283         printf("Warning: could not initialize RPC interface.\n");
 284 }
 285
 286
 287 int
 288 main(argc, argv)
 289      int argc;
 290      char **argv;
 291 {
 292     afs_int32 code = 0;
 293     struct cmd_syndesc *ts;
 294     int i;
 295
 296 #ifdef  AFS_AIX32_ENV
 297     struct sigaction nsa;
 298
 299     sigemptyset(&nsa.sa_mask);
 300     nsa.sa_handler = SIG_DFL;
 301     nsa.sa_flags = SA_FULLDUMP;
 302     sigaction(SIGSEGV, &nsa, NULL);
 303 #endif
 304
 305     /*
 306      * Look in /usr/vice/etc (client side database).
 307      */
 308     cmd_SetBeforeProc(MyBeforeProc, NULL);
 309
 310     ts = cmd_CreateSyntax("initcmd" /*"invalidatecache" */ , InvalidateCache,
 311                           0, "invalidate server ACL cache");
 312     cmd_AddParm(ts, "-id", CMD_LIST, CMD_OPTIONAL, "user identifier");
 313     cmd_AddParm(ts, "-ip", CMD_LIST, CMD_OPTIONAL, "IP address");
 314     cmd_CreateAlias(ts, "ic");
 315     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
 316
 317     ts = cmd_CreateSyntax("listservers", GetServerList, 0,
 318                           "list servers in the cell");
 319     cmd_CreateAlias(ts, "ls");
 320
 321     code = cmd_Dispatch(argc, argv);
 322
 323     rx_Finalize();
 324
 325     exit(code);
 326 }