log: Relocate pagsh
[openafs.git] / src / log / test / testlog.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 /*
11 /*
12         testlog -- Test communication with the Andrew Cache Manager.
13
14         Usage:
15                 testlog [[-x] user [password] [-c cellname]]
16
17                 where:
18                         -x indicates that no password file lookups are to be done.
19                         -c identifies cellname as the cell in which authentication is to take place.
20                             This implies -x, unless the given cellname matches our local one.
21 */
22
23 #include <afsconfig.h>
24 #include <afs/param.h>
25
26
27 #include <itc.h>
28 #include <stdio.h>
29 #include <pwd.h>
30 #include <r/xdr.h>
31 #include <afs/comauth.h>
32 #include <sys/types.h>
33 #include <netinet/in.h>
34 #include <afs/cellconfig.h>
35 #include <errno.h>
36
37 extern int errno;
38
39 #define DB_CELLS    1
40 #define DB_ARGPARSE 0
41
42
43
44 main(argc, argv)
45      int argc;
46      char *argv[];
47
48 {                               /*Main routine */
49
50     struct AllTokenInfo {
51         SecretToken sTok;
52         ClearToken cTok;
53         char cellName[MAXCELLCHARS];
54         int valid;
55     };
56
57     SecretToken sToken, testSTok;
58     ClearToken cToken, testCTok;
59     struct AllTokenInfo origInfo[100];  /*All original token info */
60     struct passwd pwent;
61     struct passwd *pw = &pwent;
62     struct passwd *lclpw = &pwent;
63     static char passwd[100] = { '\0' };
64
65     static char lclCellID[MAXCELLCHARS] = { '\0' };     /*Name of local cell */
66     static char cellID[MAXCELLCHARS] = { '\0' };        /*Name of desired cell */
67     int doLookup = TRUE;        /*Assume pwd lookup needed */
68     int foundUser = FALSE;      /*Not yet, anyway */
69     int foundPassword = FALSE;  /*Not yet, anyway */
70     int foundExplicitCell = FALSE;      /*Not yet, anyway */
71     int currArg = 0;            /*Current (true) arg num */
72     int usageError = FALSE;     /*Did user screw up args? */
73     int rc;                     /*Value of rpc return */
74     int notPrimary;             /*Log can't set primary ID */
75     int useCellEntry;           /*Do a cellular call? */
76     int isPrimary;              /*Were returned tokens primary? */
77     int cellNum;                /*Loop var for token gathering */
78
79     /*
80      * Get the tokens from the Cache Manager with both the cellular and non-cellular calls.
81      */
82     fprintf(stderr,
83             "Getting tokens from the Cache Manager (non-cellular call)\n");
84     U_GetLocalTokens(&testCTok, &testSTok);
85
86     for (cellNum = 0; cellNum < 100; cellNum++)
87         origInfo[cellNum].valid = 0;
88     fprintf(stderr,
89             "Getting tokens from the Cache Manager (cellular call)\n");
90     useCellEntry = 1;
91     cellNum = 0;
92     do {
93         printf("\t[%3d] ", cellNum);
94         rc = U_CellGetLocalTokens(useCellEntry, cellNum,
95                                   &origInfo[cellNum].cTok,
96                                   &origInfo[cellNum].sTok,
97                                   origInfo[cellNum].cellName, &isPrimary);
98         if (rc) {
99             /*Something didn't go well.  Print out errno, unless we got an EDOM */
100             if (errno == EDOM)
101                 printf("--End of list--\n");
102             else
103                 printf("** Error in call, errno is %d\n", errno);
104         } else {
105             origInfo[cellNum].valid = 1;
106             printf("Vice ID %4d in cell '%s'%s\n",
107                    origInfo[cellNum].cTok.ViceId, origInfo[cellNum].cellName,
108                    (isPrimary ? " [Primary]" : ""));
109         }
110         cellNum++;
111     } while (!(rc && (errno == EDOM)));
112
113     /*
114      * Get our local cell's name and copy it into the desired cellID buffers (assume it'll
115      * be the target cell, too).
116      */
117 #if DB_CELLS
118     fprintf(stderr, "\nGetting local cell name\n");
119 #endif /* DB_CELLS */
120     rc = GetLocalCellName();
121     if (rc != CCONF_SUCCESS)
122         fprintf(stderr, "\tCan't get local cell name!\n");
123     strcpy(lclCellID, LclCellName);
124     strcpy(cellID, LclCellName);
125     fprintf(stderr, "\tUsing '%s' as the local cell name.\n", lclCellID);
126
127     /*
128      * Parse our arguments.  The current arg number is always 0.
129      */
130     currArg = 1;
131     while (currArg < argc) {
132         /*
133          * Handle current argument.
134          */
135 #if DB_ARGPARSE
136         fprintf(stderr, "Parsing arg %d.\n", currArg);
137 #endif /* DB_ARGPARSE */
138         if (strcmp(argv[currArg], "-x") == 0) {
139             /*
140              * Found -x flag.  Remember not to do lookups if flag is the
141              * first true argument.
142              */
143             if (currArg != 1) {
144                 fprintf(stderr,
145                         "-x switch must appear before all other arguments.\n");
146                 usageError = TRUE;
147                 break;
148             }
149             doLookup = FALSE;
150             currArg++;
151 #if DB_ARGPARSE
152             fprintf(stderr, "Found legal -x flag.\n");
153 #endif /* DB_ARGPARSE */
154         } else if (strcmp(argv[currArg], "-c") == 0) {
155             /*
156              * Cell name explicitly mentioned; take it in if no other cell name has
157              * already been specified and if the name actually appears.  If the
158              * given cell name differs from our own, we don't do a lookup.
159              */
160             if (foundExplicitCell) {
161                 fprintf(stderr, "Only one -c switch allowed.\n");
162                 usageError = TRUE;
163                 break;
164             }
165             if (currArg + 1 >= argc) {
166                 fprintf(stderr, "Cell name must follow -c switch.\n");
167                 usageError = TRUE;
168                 break;
169             }
170             foundExplicitCell = TRUE;
171             if (strcmp(argv[currArg], lclCellID) != 0) {
172                 doLookup = FALSE;
173                 strcpy(cellID, argv[currArg + 1]);
174             }
175             currArg += 2;
176 #if DB_ARGPARSE
177             fprintf(stderr, "Found explicit cell name: '%s'\n", cellID);
178 #endif /* DB_ARGPARSE */
179         } else if (!foundUser) {
180             /*
181              * If it's not a -x or a -c and we haven't found the user name yet, shove it into our
182              * local password entry buffer, remembering we have it.
183              */
184             foundUser = TRUE;
185             lclpw->pw_name = argv[currArg];
186             currArg++;
187 #if DB_ARGPARSE
188             fprintf(stderr, "Found user name: '%s'\n", lclpw->pw_name);
189 #endif /* DB_ARGPARSE */
190         } else if (!foundPassword) {
191             /*
192              * Current argument is the desired password string.  Remember it in our local
193              * buffer, and zero out the argument string - anyone can see it there with ps!
194              */
195             foundPassword = TRUE;
196             strcpy(passwd, argv[currArg]);
197             memset(argv[currArg], 0, strlen(passwd));
198             currArg++;
199 #if DB_ARGPARSE
200             fprintf(stderr,
201                     "Found password: '%s' (%d chars), erased from arg list (now '%s').\n",
202                     passwd, strlen(passwd), argv[currArg - 1]);
203 #endif /* DB_ARGPARSE */
204         } else {
205             /*
206              * No more legal choices here.  Remember to tell the user (constructively)
207              * that he screwed up.
208              */
209             usageError = TRUE;
210             break;
211         }
212     }                           /*end while */
213
214     if (argc < 2) {
215         /*
216          * No arguments were provided; our only clue is the uid.
217          */
218 #if DB_ARGPARSE
219         fprintf(stderr, "No arguments, using getpwuid(getuid()).\n");
220 #endif /* DB_ARGPARSE */
221         pw = getpwuid(getuid());
222         if (pw == NULL) {
223             fprintf(stderr,
224                     "\nCan't figure out your name in local cell '%s' from your user id.\n",
225                     lclCellID);
226             fprintf(stderr, "Try providing the user name.\n");
227             fprintf(stderr,
228                     "Usage: testlog [[-x] user [password] [-c cellname]]\n\n");
229             exit(1);
230         }
231         foundUser = TRUE;
232         doLookup = FALSE;
233         lclpw = pw;
234 #if DB_ARGPARSE
235         fprintf(stderr, "Found it, user name is '%s'.\n", lclpw->pw_name);
236 #endif /* DB_ARGPARSE */
237     }
238
239     /* 
240      * Argument parsing is complete.  If the user gave us bad arguments or didn't
241      * include a user, try to mend his evil ways.
242      */
243     if (usageError || !foundUser) {
244         fprintf(stderr,
245                 "Usage: testlog [[-x] user [password] [-c cellname]]\n\n");
246         exit(1);
247     }
248
249     /*
250      * If we need to do a lookup on the user name (no -x flag, wants local cell, not already
251      * looked up), then do it.
252      */
253     if (doLookup) {
254         pw = getpwnam(lclpw->pw_name);
255         if (pw == NULL) {
256             fprintf(stderr, "'%s' is not a valid user in local cell '%s'.\n",
257                     lclpw->pw_name, lclCellID);
258             exit(1);
259         }
260 #if DB_ARGPARSE
261         fprintf(stderr, "Lookup on user name '%s' succeeded.\n", pw->pw_name);
262 #endif /* DB_ARGPARSE */
263     }
264
265     /*
266      * Having all the info we need, we initialize our RPC connection.
267      */
268     if (U_InitRPC() != 0) {
269         fprintf(stderr, "%s: Problems with RPC (U_InitRPC failed).\n",
270                 argv[0]);
271         exit(1);
272     }
273
274     /*
275      * Get the password if it was not provided.
276      */
277     if (passwd[0] == '\0') {
278         char buf[128];
279
280         sprintf(buf, "Password for user '%s' in cell '%s': ", lclpw->pw_name,
281                 cellID);
282         strcpy(passwd, getpass(buf));
283     }
284
285     /*
286      * Get the corresponding set of tokens from an AuthServer.
287      */
288     fprintf(stderr, "Trying standard cellular authentication.\n");
289 #if DB_CELLS
290     cToken.ViceId = 123;
291 #endif /* DB_CELLS */
292     if ((rc =
293          U_CellAuthenticate(pw->pw_name, passwd, cellID, &cToken, &sToken))
294         != AUTH_SUCCESS)
295         fprintf(stderr, "\tInvalid login: code %d ('%s').\n", rc,
296                 U_Error(rc));
297 #if DB_CELLS
298     else {
299         fprintf(stderr, "\tCell authentication successful.\n");
300         fprintf(stderr, "\tViceID field of clear token returned: %d\n",
301                 cToken.ViceId);
302     }
303 #endif /* DB_CELLS */
304
305     /*
306      * Give the non-primary tokens to the Cache Manager, along with the cell they're good for.
307      */
308     fprintf(stderr, "\nGiving tokens to Cache Manager (non-cellular call)\n");
309     rc = U_SetLocalTokens(0, &cToken, &sToken);
310     if (rc)
311         fprintf(stderr, "\tError: code %d ('%s')\n", rc, U_Error(rc));
312     fprintf(stderr,
313             "Giving tokens to Cache Manager (cellular call, cell = '%s')\n",
314             cellID);
315     notPrimary = 0;
316     if (rc =
317         U_CellSetLocalTokens(0, &cToken, &sToken, cellID,
318                              notPrimary) != AUTH_SUCCESS)
319         fprintf(stderr, "\tError: code %d ('%s')\n", rc, U_Error(rc));
320
321     /*
322      * Restore all the original tokens.
323      */
324     fprintf(stderr, "\nRestoring all original tokens.\n");
325     for (cellNum = 0; cellNum < 100; cellNum++)
326         if (origInfo[cellNum].valid) {
327             fprintf(stderr, "\tuid %4d in cell '%s'\n",
328                     origInfo[cellNum].cTok.ViceId,
329                     origInfo[cellNum].cellName);
330             if (rc =
331                 U_CellSetLocalTokens(0, &origInfo[cellNum].cTok,
332                                      &origInfo[cellNum].sTok,
333                                      origInfo[cellNum].cellName,
334                                      notPrimary) != AUTH_SUCCESS)
335                 fprintf(stderr, "\t** Error: code %d ('%s')\n", rc,
336                         U_Error(rc));
337         }
338
339 }                               /*Main routine */