improve command-line help for --enable_peer_stats
[openafs.git] / src / update / server.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 <afsconfig.h>
11 #include <afs/param.h>
12 #include <afs/stds.h>
13
14 #include <afs/procmgmt.h>
15 #include <roken.h>
16 #include <afs/opr.h>
17
18 #ifdef AFS_NT40_ENV
19 #include <WINNT/afsevent.h>
20 #endif
21
22 #ifdef  AFS_AIX_ENV
23 #include <sys/statfs.h>
24 #endif
25
26 #include <rx/xdr.h>
27 #include <rx/rx.h>
28 #include <rx/rxkad.h>
29 #include <afs/cellconfig.h>
30 #include <afs/afsutil.h>
31 #include <afs/fileutil.h>
32 #include <afs/com_err.h>
33
34 #include "update.h"
35 #include "global.h"
36
37 static int AddObject(char **expPath, char *dir);
38 static int PathInDirectory(char *dir, char *path);
39 int update_SendFile(int, struct rx_call *, struct stat *);
40 int update_SendDirInfo(char *, struct rx_call *, struct stat *,
41                        char *origDir);
42
43 struct afsconf_dir *cdir;
44 int nDirs;
45 char *dirName[MAXENTRIES];
46 int dirLevel[MAXENTRIES];
47 char *whoami;
48
49 static int Quit(char *);
50
51 int rxBind = 0;
52
53 #define ADDRSPERSITE 16         /* Same global is in rx/rx_user.c */
54 afs_uint32 SHostAddrs[ADDRSPERSITE];
55
56 /* check whether caller is authorized to manage RX statistics */
57 int
58 update_rxstat_userok(struct rx_call *call)
59 {
60     return afsconf_SuperUser(cdir, call, NULL);
61 }
62
63 /*
64  * PathInDirectory() -- determine if path is in directory (or is directory)
65  * Returns 1 if yes, 0 if no, -1 on error.
66  */
67 static int
68 PathInDirectory(char *dir, char *path)
69 {
70     int inDir = 0, code;
71     size_t dirLen;
72     char *dirNorm, *pathNorm;
73
74 #ifdef AFS_NT40_ENV
75     /* case-insensitive comparison of normalized, same-flavor (short) paths */
76     DWORD status;
77
78     dirNorm = malloc(AFSDIR_PATH_MAX);
79     if (dirNorm == NULL)
80         return -1;
81     status = GetShortPathName(dir, dirNorm, AFSDIR_PATH_MAX);
82     if (status == 0 || status > AFSDIR_PATH_MAX) {
83         /* can't convert path to short version; just use long version */
84         free(dirNorm);
85         dirNorm = strdup(dir);
86         if (dirNorm == NULL)
87             return -1;
88     }
89     FilepathNormalize(dirNorm);
90
91     pathNorm = malloc(AFSDIR_PATH_MAX);
92     if (pathNorm == NULL) {
93         code = -1;
94         goto out;
95     }
96     status = GetShortPathName(path, pathNorm, AFSDIR_PATH_MAX);
97     if (status == 0 || status > AFSDIR_PATH_MAX) {
98         /* can't convert path to short version; just use long version */
99         free(pathNorm);
100         pathNorm = strdup(path);
101         if (pathNorm == NULL) {
102             code = -1;
103             goto out;
104         }
105     }
106     FilepathNormalize(pathNorm);
107
108     dirLen = strlen(dirNorm);
109
110     if (_strnicmp(dirNorm, pathNorm, dirLen) == 0) {
111         /* substrings match; path must match dir or be subdirectory */
112         if (pathNorm[dirLen] == '\0' || pathNorm[dirLen] == '/') {
113             inDir = 1;
114         }
115     }
116 #else
117     /* case-sensitive comparison of normalized paths */
118     dirNorm = strdup(dir);
119     if (dirNorm == NULL)
120         return -1;
121     FilepathNormalize(dirNorm);
122
123     pathNorm = strdup(path);
124     if (pathNorm == NULL) {
125         code = -1;
126         goto out;
127     }
128     FilepathNormalize(pathNorm);
129
130     dirLen = strlen(dirNorm);
131
132     if (strncmp(dirNorm, pathNorm, dirLen) == 0) {
133         /* substrings match; path must match dir or be subdirectory */
134         if (pathNorm[dirLen] == '\0' || pathNorm[dirLen] == '/') {
135             inDir = 1;
136         }
137     }
138 #endif /* AFS_NT40_ENV */
139     code = 0;
140 out:
141     free(dirNorm);
142     free(pathNorm);
143     return (code != 0) ? code : inDir;
144 }
145
146 int
147 AuthOkay(struct rx_call *call, char *name)
148 {
149     int i, r;
150     rxkad_level level;
151     afs_int32 code;
152     int matches;
153
154     /* Must be in 'UserList' to use */
155     if (!afsconf_SuperUser(cdir, call, NULL))
156         return 0;
157
158     if (rx_SecurityClassOf(rx_ConnectionOf(call)) == RX_SECIDX_KAD) {
159         code = rxkad_GetServerInfo(rx_ConnectionOf(call), &level, 0, 0, 0, 0, 0);
160         if (code)
161             return 0;
162     } else
163         level = 0;
164
165     matches = 0;
166     for (i = 0; i < nDirs; i++) {
167         r = PathInDirectory(dirName[i], name);
168         if (r < 0)
169             return 0;
170         if (r) {
171             if (dirLevel[i] > level)
172                 return 0;
173             matches++;
174             /* keep searching in case there's a more restrictive subtree
175              * specified later. */
176         }
177     }
178     if (nDirs && !matches)
179         return 0;               /* if dirs spec., name must match */
180     return 1;                   /* okay or no dirs */
181 }
182
183 int
184 osi_audit(void)
185 {
186 /* this sucks but it works for now.
187 */
188     return 0;
189 }
190
191 #ifndef AFS_NT40_ENV
192 #include "AFS_component_version_number.c"
193 #endif
194
195 int
196 main(int argc, char *argv[])
197 {
198     struct rx_securityClass **securityClasses;
199     afs_int32 numClasses;
200     struct rx_service *service;
201     char hoststr[16];
202     afs_uint32 host = htonl(INADDR_ANY);
203
204     int a = 0;
205     rxkad_level level;
206     rxkad_level newLevel;
207
208 #ifdef  AFS_AIX32_ENV
209     /*
210      * The following signal action for AIX is necessary so that in case of a
211      * crash (i.e. core is generated) we can include the user's data section
212      * in the core dump. Unfortunately, by default, only a partial core is
213      * generated which, in many cases, isn't too useful.
214      */
215     struct sigaction nsa;
216
217     sigemptyset(&nsa.sa_mask);
218     nsa.sa_handler = SIG_DFL;
219     nsa.sa_flags = SA_FULLDUMP;
220     sigaction(SIGABRT, &nsa, NULL);
221     sigaction(SIGSEGV, &nsa, NULL);
222 #endif
223
224     whoami = argv[0];
225
226 #ifdef AFS_NT40_ENV
227     /* dummy signal call to force afsprocmgmt.dll to load on NT */
228     signal(SIGUSR1, SIG_DFL);
229 #endif
230
231     /* Initialize dirpaths */
232     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
233 #ifdef AFS_NT40_ENV
234         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
235 #endif
236         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
237                 argv[0]);
238         exit(2);
239     }
240     nDirs = 0;
241     level = rxkad_clear;
242
243     if (argc == 1)              /* no arguments */
244         goto usage;
245
246     /* support help flag */
247     if (strcmp("-help", argv[1]) == 0)
248         goto usage;
249     if (strcmp("help", argv[1]) == 0)
250         goto usage;
251
252     for (a = 1; a < argc; a++) {
253         if (argv[a][0] == '-') {        /* parse options */
254             if (strcmp(argv[a], "-rxbind") == 0) {
255                 rxBind = 1;
256                 continue;
257             } else {
258                 char arg[256];
259                 lcstring(arg, argv[a], sizeof(arg));
260                 newLevel = rxkad_StringToLevel(&argv[a][1]);
261                 if (newLevel != -1) {
262                     level = newLevel;   /* set new level */
263                     continue;
264                 }
265             }
266           usage:
267             Quit("Usage: upserver [<directory>+] [-crypt <directory>+] [-clear <directory>+] [-auth <directory>+] [-rxbind] [-help]\n");
268         } else {
269             if (nDirs >= sizeof(dirName) / sizeof(dirName[0]))
270                 Quit("Too many dirs");
271             if (AddObject(&dirName[nDirs], argv[a])) {
272                 printf("%s: Unable to export dir %s. Skipping\n", whoami,
273                        argv[a]);
274                 continue;
275             }
276             dirLevel[nDirs] = level;    /* remember current level */
277             nDirs++;
278         }
279     }
280
281     if (nDirs == 0) {           /* Didn't find any directories to export */
282         printf("%s: No directories to export. Quitting\n", whoami);
283         exit(1);
284     }
285
286     cdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH);
287     if (cdir == 0) {
288         fprintf(stderr, "Can't get server configuration info (%s)\n",
289                 AFSDIR_SERVER_ETC_DIRPATH);
290         exit(1);
291     }
292
293     if (rxBind) {
294         afs_int32 ccode;
295         if (AFSDIR_SERVER_NETRESTRICT_FILEPATH ||
296             AFSDIR_SERVER_NETINFO_FILEPATH) {
297             char reason[1024];
298             ccode = afsconf_ParseNetFiles(SHostAddrs, NULL, NULL,
299                                           ADDRSPERSITE, reason,
300                                           AFSDIR_SERVER_NETINFO_FILEPATH,
301                                           AFSDIR_SERVER_NETRESTRICT_FILEPATH);
302         } else
303         {
304             ccode = rx_getAllAddr(SHostAddrs, ADDRSPERSITE);
305         }
306         if (ccode == 1)
307             host = SHostAddrs[0];
308     }
309
310     /* Initialize Rx, telling it port number this server will use for its
311      * single service */
312     fprintf(stderr, "upserver binding rx to %s:%d\n",
313             afs_inet_ntoa_r(host, hoststr), AFSCONF_UPDATEPORT);
314     if (rx_InitHost(host, htons(AFSCONF_UPDATEPORT)) < 0)
315         Quit("rx_init");
316
317     afsconf_BuildServerSecurityObjects(cdir, &securityClasses, &numClasses);
318
319     if (securityClasses[2] == NULL)
320         Quit("rxkad_NewServerSecurityObject");
321
322     /* Instantiate a single UPDATE service.  The rxgen-generated procedure
323      * which is called to decode requests is passed in here
324      * (UPDATE_ExecuteRequest). */
325     service =
326         rx_NewServiceHost(host, 0, UPDATE_SERVICEID, "UPDATE", securityClasses,
327                           numClasses, UPDATE_ExecuteRequest);
328     if (service == (struct rx_service *)0)
329         Quit("rx_NewService");
330     rx_SetMaxProcs(service, 2);
331
332     /* allow super users to manage RX statistics */
333     rx_SetRxStatUserOk(update_rxstat_userok);
334
335     rx_StartServer(1);          /* Donate this process to the server process pool */
336     Quit("StartServer returned?");
337     return 0;
338 }
339
340 /* fetch the file name and send it to the remote requester specified by call */
341
342 int
343 UPDATE_FetchFile(struct rx_call *call, char *name)
344 {
345     int fd = -1;
346     int error = 0;
347     struct stat status;
348     char *reqObject;
349
350     /* construct a local path from a canonical (wire-format) path */
351     if ((error = ConstructLocalPath(name, "/", &reqObject))) {
352         afs_com_err(whoami, error, "Unable to construct local path");
353         return UPDATE_ERROR;
354     }
355
356     if (!AuthOkay(call, reqObject)) {
357         error = UPDATE_ERROR;
358     } else {
359         fd = open(reqObject, O_RDONLY, 0);
360         if (fd < 0 || fstat(fd, &status) < 0) {
361             printf("Failed to open %s\n", reqObject);
362             error = UPDATE_ERROR;
363         }
364         if (!error)
365             error = update_SendFile(fd, call, &status);
366         if (fd >= 0)
367             close(fd);
368     }
369     free(reqObject);
370     return error;
371 }
372
373 /* fetch dir info about directory name and send it to remote host associated
374   with call. */
375 int
376 UPDATE_FetchInfo(struct rx_call *call, char *name)
377 {
378     int error = 0;
379     struct stat status;
380     char *reqObject;
381
382     /* construct a local path from a canonical (wire-format) path */
383     if ((error = ConstructLocalPath(name, "/", &reqObject))) {
384         afs_com_err(whoami, error, "Unable to construct local path");
385         return UPDATE_ERROR;
386     }
387
388     if (!AuthOkay(call, reqObject)) {
389         error = UPDATE_ERROR;
390     } else {
391         /* we only need to stat the obj, not open it. */
392         if (stat(reqObject, &status) < 0) {
393             printf("Failed to open %s\n", reqObject);
394             error = UPDATE_ERROR;
395         }
396         if ((status.st_mode & S_IFMT) != S_IFDIR) {
397             printf(" file %s is not a directory \n", reqObject);
398             error = -1;
399         }
400
401         if (!error)
402             error = update_SendDirInfo(reqObject, call, &status, name);
403     }
404     free(reqObject);
405     return error;
406 }
407
408 static int
409 Quit(char *msg)
410 {
411     fprintf(stderr, "%s", msg);
412     exit(1);
413 }
414
415 int
416 update_SendFile(int fd, struct rx_call *call, struct stat *status)
417 {
418     char *buffer = (char *)0;
419     int blockSize;
420     afs_int32 length, tlen;
421 #ifdef  AFS_AIX_ENV
422     struct statfs tstatfs;
423 #endif
424
425     afs_int32 error = 0;
426 #ifdef  AFS_AIX_ENV
427     /* Unfortunately in AIX valuable fields such as st_blksize are gone from the stat structure!! */
428     fstatfs(fd, &tstatfs);
429     blockSize = tstatfs.f_bsize;
430 #elif AFS_NT40_ENV
431     blockSize = 4096;
432 #else
433     blockSize = status->st_blksize;
434 #endif
435     length = status->st_size;
436     buffer = malloc(blockSize);
437     if (!buffer) {
438         printf("malloc failed\n");
439         return UPDATE_ERROR;
440     }
441     tlen = htonl(length);
442     rx_Write(call, (char *)&tlen, sizeof(afs_int32));   /* send length on fetch */
443     while (!error && length) {
444         int nbytes = (length > blockSize ? blockSize : length);
445         nbytes = read(fd, buffer, nbytes);
446         if (nbytes <= 0) {
447             fprintf(stderr, "File system read failed\n");
448             break;
449         }
450         if (rx_Write(call, buffer, nbytes) != nbytes)
451             break;
452         length -= nbytes;
453     }
454     if (buffer)
455         free(buffer);
456     if (length)
457         error = UPDATE_ERROR;
458     return error;
459 }
460
461 /* Enumerate dir (name) and write dir entry info into temp file.
462  */
463 int
464 update_SendDirInfo(char *name,          /* Name of dir to enumerate */
465      struct rx_call *call,      /* rx call */
466      struct stat *status,       /* stat struct for dir */
467      char *origDir)             /* orig name of dir before being localized */
468 {
469     DIR *dirp;
470     struct dirent *dp;
471     FILE *stream;
472     struct stat tstatus;
473     char filename[MAXFNSIZE], dirInfoFile[MAXFNSIZE];
474     int fd, tfd, errcode, error, err;
475
476     error = 0;
477     dirp = opendir(name);
478     sprintf(dirInfoFile, "%s/upserver.tmp", gettmpdir());
479     stream = fopen(dirInfoFile, "w");
480     if (!stream) {
481         error = EIO;
482     } else {
483         while ((dp = readdir(dirp))) {
484             strcpy(filename, name);
485             strcat(filename, "/");
486             strcat(filename, dp->d_name);
487
488             tfd = open(filename, O_RDONLY, 0);
489             if (tfd < 0 || fstat(tfd, &tstatus) < 0) {
490                 printf("Failed to open %s\n", name);
491                 error = UPDATE_ERROR;
492                 goto fail;
493             }
494             if ((tstatus.st_mode & S_IFMT) != S_IFDIR) {        /* not a directory */
495                 char dirEntry[MAXFNSIZE];
496
497                 strcpy(dirEntry, origDir);
498                 strcat(dirEntry, "/");
499                 strcat(dirEntry, dp->d_name);
500                 err =
501                     fprintf(stream, "\"%s\" %u %u %u %u %u %u\n", dirEntry,
502                             (unsigned int)tstatus.st_mtime,
503                             (unsigned int)tstatus.st_size, tstatus.st_mode,
504                             tstatus.st_uid, tstatus.st_gid,
505                             (unsigned int)tstatus.st_atime);
506                 if (err < 0)
507                     error = EIO;
508             }
509             err = close(tfd);
510             if (err) {
511                 printf("could not close file %s \n", filename);
512                 error = UPDATE_ERROR;
513                 goto fail;
514             }
515         }
516     }
517   fail:
518     if (dirp)
519         closedir(dirp);
520     if (stream) {
521         if (ferror(stream))
522             if (!error)
523                 error = UPDATE_ERROR;
524         fclose(stream);
525     }
526     if (error == 0) {
527         fd = open(dirInfoFile, O_RDONLY, 0);
528         if (fd >= 0) {
529             fstat(fd, &tstatus);
530             errcode = update_SendFile(fd, call, &tstatus);
531             if (errcode)
532                 if (!error)
533                     error = UPDATE_ERROR;
534             close(fd);
535         }
536     }
537     unlink(dirInfoFile);
538     return error;
539 }
540
541
542 /* AddObject() - Adds the object to the list of exported objects after
543  *     converting to a local path.
544  *
545  * expPath : points to allocated storage in which the exportable path is
546  *           passed back.
547  * dir     : dir name passed in for export
548  *
549  */
550 static int
551 AddObject(char **expPath, char *dir)
552 {
553     int error;
554     struct stat statbuf;
555
556     /* construct a local path from a canonical (wire-format) path */
557     if ((error = ConstructLocalPath(dir, "/", expPath))) {
558         afs_com_err(whoami, error, "Unable to construct local path");
559         return error;
560     }
561
562     /* stat the object */
563     error = stat(*expPath, &statbuf);
564     if (error) {
565         afs_com_err(whoami, error, ";Can't stat object.");
566         return error;
567     }
568     /* now check if the object has an exportable (file/dir)  type */
569     if (!(statbuf.st_mode & S_IFDIR)) {
570         fprintf(stderr, "%s: Unacceptable object type for %s\n", whoami,
571                 *expPath);
572         return -1;
573     }
574
575     return 0;
576 }