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