c2985d375353a0f8222fef3d22c25bd5e1a7c9d1
[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     afs_uint32 host = htonl(INADDR_ANY);
202
203     int a = 0;
204     rxkad_level level;
205     rxkad_level newLevel;
206
207 #ifdef  AFS_AIX32_ENV
208     /*
209      * The following signal action for AIX is necessary so that in case of a
210      * crash (i.e. core is generated) we can include the user's data section
211      * in the core dump. Unfortunately, by default, only a partial core is
212      * generated which, in many cases, isn't too useful.
213      */
214     struct sigaction nsa;
215
216     sigemptyset(&nsa.sa_mask);
217     nsa.sa_handler = SIG_DFL;
218     nsa.sa_flags = SA_FULLDUMP;
219     sigaction(SIGABRT, &nsa, NULL);
220     sigaction(SIGSEGV, &nsa, NULL);
221 #endif
222
223     whoami = argv[0];
224
225 #ifdef AFS_NT40_ENV
226     /* dummy signal call to force afsprocmgmt.dll to load on NT */
227     signal(SIGUSR1, SIG_DFL);
228 #endif
229
230     /* Initialize dirpaths */
231     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
232 #ifdef AFS_NT40_ENV
233         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
234 #endif
235         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
236                 argv[0]);
237         exit(2);
238     }
239     nDirs = 0;
240     level = rxkad_clear;
241
242     if (argc == 1)              /* no arguments */
243         goto usage;
244
245     /* support help flag */
246     if (strcmp("-help", argv[1]) == 0)
247         goto usage;
248     if (strcmp("help", argv[1]) == 0)
249         goto usage;
250
251     for (a = 1; a < argc; a++) {
252         if (argv[a][0] == '-') {        /* parse options */
253             if (strcmp(argv[a], "-rxbind") == 0) {
254                 rxBind = 1;
255                 continue;
256             } else {
257                 char arg[256];
258                 lcstring(arg, argv[a], sizeof(arg));
259                 newLevel = rxkad_StringToLevel(&argv[a][1]);
260                 if (newLevel != -1) {
261                     level = newLevel;   /* set new level */
262                     continue;
263                 }
264             }
265           usage:
266             Quit("Usage: upserver [<directory>+] [-crypt <directory>+] [-clear <directory>+] [-auth <directory>+] [-rxbind] [-help]\n");
267         } else {
268             if (nDirs >= sizeof(dirName) / sizeof(dirName[0]))
269                 Quit("Too many dirs");
270             if (AddObject(&dirName[nDirs], argv[a])) {
271                 printf("%s: Unable to export dir %s. Skipping\n", whoami,
272                        argv[a]);
273                 continue;
274             }
275             dirLevel[nDirs] = level;    /* remember current level */
276             nDirs++;
277         }
278     }
279
280     if (nDirs == 0) {           /* Didn't find any directories to export */
281         printf("%s: No directories to export. Quitting\n", whoami);
282         exit(1);
283     }
284
285     cdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH);
286     if (cdir == 0) {
287         fprintf(stderr, "Can't get server configuration info (%s)\n",
288                 AFSDIR_SERVER_ETC_DIRPATH);
289         exit(1);
290     }
291
292     if (rxBind) {
293         afs_int32 ccode;
294         if (AFSDIR_SERVER_NETRESTRICT_FILEPATH ||
295             AFSDIR_SERVER_NETINFO_FILEPATH) {
296             char reason[1024];
297             ccode = afsconf_ParseNetFiles(SHostAddrs, NULL, NULL,
298                                           ADDRSPERSITE, reason,
299                                           AFSDIR_SERVER_NETINFO_FILEPATH,
300                                           AFSDIR_SERVER_NETRESTRICT_FILEPATH);
301         } else
302         {
303             ccode = rx_getAllAddr(SHostAddrs, ADDRSPERSITE);
304         }
305         if (ccode == 1)
306             host = SHostAddrs[0];
307     }
308
309     /* Initialize Rx, telling it port number this server will use for its
310      * single service */
311     if (rx_InitHost(host, htons(AFSCONF_UPDATEPORT)) < 0)
312         Quit("rx_init");
313
314     afsconf_BuildServerSecurityObjects(cdir, &securityClasses, &numClasses);
315
316     if (securityClasses[2] == NULL)
317         Quit("rxkad_NewServerSecurityObject");
318
319     /* Instantiate a single UPDATE service.  The rxgen-generated procedure
320      * which is called to decode requests is passed in here
321      * (UPDATE_ExecuteRequest). */
322     service =
323         rx_NewServiceHost(host, 0, UPDATE_SERVICEID, "UPDATE", securityClasses,
324                           numClasses, UPDATE_ExecuteRequest);
325     if (service == (struct rx_service *)0)
326         Quit("rx_NewService");
327     rx_SetMaxProcs(service, 2);
328
329     /* allow super users to manage RX statistics */
330     rx_SetRxStatUserOk(update_rxstat_userok);
331
332     rx_StartServer(1);          /* Donate this process to the server process pool */
333     Quit("StartServer returned?");
334     return 0;
335 }
336
337 /* fetch the file name and send it to the remote requester specified by call */
338
339 int
340 UPDATE_FetchFile(struct rx_call *call, char *name)
341 {
342     int fd = -1;
343     int error = 0;
344     struct stat status;
345     char *reqObject;
346
347     /* construct a local path from a canonical (wire-format) path */
348     if ((error = ConstructLocalPath(name, "/", &reqObject))) {
349         afs_com_err(whoami, error, "Unable to construct local path");
350         return UPDATE_ERROR;
351     }
352
353     if (!AuthOkay(call, reqObject)) {
354         error = UPDATE_ERROR;
355     } else {
356         fd = open(reqObject, O_RDONLY, 0);
357         if (fd < 0 || fstat(fd, &status) < 0) {
358             printf("Failed to open %s\n", reqObject);
359             error = UPDATE_ERROR;
360         }
361         if (!error)
362             error = update_SendFile(fd, call, &status);
363         if (fd >= 0)
364             close(fd);
365     }
366     free(reqObject);
367     return error;
368 }
369
370 /* fetch dir info about directory name and send it to remote host associated
371   with call. */
372 int
373 UPDATE_FetchInfo(struct rx_call *call, char *name)
374 {
375     int error = 0;
376     struct stat status;
377     char *reqObject;
378
379     /* construct a local path from a canonical (wire-format) path */
380     if ((error = ConstructLocalPath(name, "/", &reqObject))) {
381         afs_com_err(whoami, error, "Unable to construct local path");
382         return UPDATE_ERROR;
383     }
384
385     if (!AuthOkay(call, reqObject)) {
386         error = UPDATE_ERROR;
387     } else {
388         /* we only need to stat the obj, not open it. */
389         if (stat(reqObject, &status) < 0) {
390             printf("Failed to open %s\n", reqObject);
391             error = UPDATE_ERROR;
392         }
393         if ((status.st_mode & S_IFMT) != S_IFDIR) {
394             printf(" file %s is not a directory \n", reqObject);
395             error = -1;
396         }
397
398         if (!error)
399             error = update_SendDirInfo(reqObject, call, &status, name);
400     }
401     free(reqObject);
402     return error;
403 }
404
405 static int
406 Quit(char *msg)
407 {
408     fprintf(stderr, "%s", msg);
409     exit(1);
410 }
411
412 int
413 update_SendFile(int fd, struct rx_call *call, struct stat *status)
414 {
415     char *buffer = (char *)0;
416     int blockSize;
417     afs_int32 length, tlen;
418 #ifdef  AFS_AIX_ENV
419     struct statfs tstatfs;
420 #endif
421
422     afs_int32 error = 0;
423 #ifdef  AFS_AIX_ENV
424     /* Unfortunately in AIX valuable fields such as st_blksize are gone from the stat structure!! */
425     fstatfs(fd, &tstatfs);
426     blockSize = tstatfs.f_bsize;
427 #elif AFS_NT40_ENV
428     blockSize = 4096;
429 #else
430     blockSize = status->st_blksize;
431 #endif
432     length = status->st_size;
433     buffer = malloc(blockSize);
434     if (!buffer) {
435         printf("malloc failed\n");
436         return UPDATE_ERROR;
437     }
438     tlen = htonl(length);
439     rx_Write(call, (char *)&tlen, sizeof(afs_int32));   /* send length on fetch */
440     while (!error && length) {
441         int nbytes = (length > blockSize ? blockSize : length);
442         nbytes = read(fd, buffer, nbytes);
443         if (nbytes <= 0) {
444             fprintf(stderr, "File system read failed\n");
445             break;
446         }
447         if (rx_Write(call, buffer, nbytes) != nbytes)
448             break;
449         length -= nbytes;
450     }
451     if (buffer)
452         free(buffer);
453     if (length)
454         error = UPDATE_ERROR;
455     return error;
456 }
457
458 /* Enumerate dir (name) and write dir entry info into temp file.
459  */
460 int
461 update_SendDirInfo(char *name,          /* Name of dir to enumerate */
462      struct rx_call *call,      /* rx call */
463      struct stat *status,       /* stat struct for dir */
464      char *origDir)             /* orig name of dir before being localized */
465 {
466     DIR *dirp;
467     struct dirent *dp;
468     FILE *stream;
469     struct stat tstatus;
470     char filename[MAXFNSIZE], dirInfoFile[MAXFNSIZE];
471     int fd, tfd, errcode, error, err;
472
473     error = 0;
474     dirp = opendir(name);
475     sprintf(dirInfoFile, "%s/upserver.tmp", gettmpdir());
476     stream = fopen(dirInfoFile, "w");
477     if (!stream) {
478         error = EIO;
479     } else {
480         while ((dp = readdir(dirp))) {
481             strcpy(filename, name);
482             strcat(filename, "/");
483             strcat(filename, dp->d_name);
484
485             tfd = open(filename, O_RDONLY, 0);
486             if (tfd < 0 || fstat(tfd, &tstatus) < 0) {
487                 printf("Failed to open %s\n", name);
488                 error = UPDATE_ERROR;
489                 goto fail;
490             }
491             if ((tstatus.st_mode & S_IFMT) != S_IFDIR) {        /* not a directory */
492                 char dirEntry[MAXFNSIZE];
493
494                 strcpy(dirEntry, origDir);
495                 strcat(dirEntry, "/");
496                 strcat(dirEntry, dp->d_name);
497                 err =
498                     fprintf(stream, "\"%s\" %u %u %u %u %u %u\n", dirEntry,
499                             (unsigned int)tstatus.st_mtime,
500                             (unsigned int)tstatus.st_size, tstatus.st_mode,
501                             tstatus.st_uid, tstatus.st_gid,
502                             (unsigned int)tstatus.st_atime);
503                 if (err < 0)
504                     error = EIO;
505             }
506             err = close(tfd);
507             if (err) {
508                 printf("could not close file %s \n", filename);
509                 error = UPDATE_ERROR;
510                 goto fail;
511             }
512         }
513     }
514   fail:
515     if (dirp)
516         closedir(dirp);
517     if (stream) {
518         if (ferror(stream))
519             if (!error)
520                 error = UPDATE_ERROR;
521         fclose(stream);
522     }
523     if (error == 0) {
524         fd = open(dirInfoFile, O_RDONLY, 0);
525         if (fd >= 0) {
526             fstat(fd, &tstatus);
527             errcode = update_SendFile(fd, call, &tstatus);
528             if (errcode)
529                 if (!error)
530                     error = UPDATE_ERROR;
531             close(fd);
532         }
533     }
534     unlink(dirInfoFile);
535     return error;
536 }
537
538
539 /* AddObject() - Adds the object to the list of exported objects after
540  *     converting to a local path.
541  *
542  * expPath : points to allocated storage in which the exportable path is
543  *           passed back.
544  * dir     : dir name passed in for export
545  *
546  */
547 static int
548 AddObject(char **expPath, char *dir)
549 {
550     int error;
551     struct stat statbuf;
552
553     /* construct a local path from a canonical (wire-format) path */
554     if ((error = ConstructLocalPath(dir, "/", expPath))) {
555         afs_com_err(whoami, error, "Unable to construct local path");
556         return error;
557     }
558
559     /* stat the object */
560     error = stat(*expPath, &statbuf);
561     if (error) {
562         afs_com_err(whoami, error, ";Can't stat object.");
563         return error;
564     }
565     /* now check if the object has an exportable (file/dir)  type */
566     if (!(statbuf.st_mode & S_IFDIR)) {
567         fprintf(stderr, "%s: Unacceptable object type for %s\n", whoami,
568                 *expPath);
569         return -1;
570     }
571
572     return 0;
573 }