netrestrict-netinfo-20081129
[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
13 RCSID
14     ("$Header$");
15
16 #include <afs/stds.h>
17 #ifdef  AFS_AIX32_ENV
18 #include <signal.h>
19 #endif
20 #include <sys/types.h>
21 #ifdef AFS_NT40_ENV
22 #include <winsock2.h>
23 #include <WINNT/afsevent.h>
24 #include <fcntl.h>
25 #include <io.h>
26 #include <afs/dirent.h>
27 #include <afs/procmgmt.h>
28 #else
29 #include <netdb.h>
30 #include <netinet/in.h>
31 #include <sys/file.h>
32 #include <dirent.h>
33 #endif
34 #include <string.h>
35 #ifdef HAVE_UNISTD_H
36 #include <unistd.h>
37 #endif
38 #include <sys/stat.h>
39 #include <errno.h>
40 #include <stdio.h>
41 #include <rx/xdr.h>
42 #include <rx/rx.h>
43 #include <rx/rxkad.h>
44 #include <afs/cellconfig.h>
45 #include <afs/afsutil.h>
46 #include <afs/fileutil.h>
47 #include <afs/com_err.h>
48 #ifdef  AFS_AIX_ENV
49 #include <sys/statfs.h>
50 #endif
51 #include "update.h"
52 #include "global.h"
53
54 extern int UPDATE_ExecuteRequest();
55
56 static int AddObject(char **expPath, char *dir);
57 static int PathInDirectory(char *dir, char *path);
58
59 struct afsconf_dir *cdir;
60 int nDirs;
61 char *dirName[MAXENTRIES];
62 int dirLevel[MAXENTRIES];
63 char *whoami;
64
65 static int Quit();
66
67 int rxBind = 0;
68
69 #define ADDRSPERSITE 16         /* Same global is in rx/rx_user.c */
70 afs_uint32 SHostAddrs[ADDRSPERSITE];
71
72 /* check whether caller is authorized to manage RX statistics */
73 int
74 update_rxstat_userok(struct rx_call *call)
75 {
76     return afsconf_SuperUser(cdir, call, NULL);
77 }
78
79 /*
80  * PathInDirectory() -- determine if path is in directory (or is directory)
81  */
82 static int
83 PathInDirectory(char *dir, char *path)
84 {
85     int inDir = 0;
86     size_t dirLen;
87     char dirNorm[AFSDIR_PATH_MAX], pathNorm[AFSDIR_PATH_MAX];
88
89 #ifdef AFS_NT40_ENV
90     /* case-insensitive comparison of normalized, same-flavor (short) paths */
91     DWORD status;
92
93     status = GetShortPathName(dir, dirNorm, AFSDIR_PATH_MAX);
94     if (status == 0 || status > AFSDIR_PATH_MAX) {
95         /* can't convert path to short version; just use long version */
96         strcpy(dirNorm, dir);
97     }
98     FilepathNormalize(dirNorm);
99
100     status = GetShortPathName(path, pathNorm, AFSDIR_PATH_MAX);
101     if (status == 0 || status > AFSDIR_PATH_MAX) {
102         /* can't convert path to short version; just use long version */
103         strcpy(pathNorm, path);
104     }
105     FilepathNormalize(pathNorm);
106
107     dirLen = strlen(dirNorm);
108
109     if (_strnicmp(dirNorm, pathNorm, dirLen) == 0) {
110         /* substrings match; path must match dir or be subdirectory */
111         if (pathNorm[dirLen] == '\0' || pathNorm[dirLen] == '/') {
112             inDir = 1;
113         }
114     }
115 #else
116     /* case-sensitive comparison of normalized paths */
117     strcpy(dirNorm, dir);
118     FilepathNormalize(dirNorm);
119
120     strcpy(pathNorm, path);
121     FilepathNormalize(pathNorm);
122
123     dirLen = strlen(dirNorm);
124
125     if (strncmp(dirNorm, pathNorm, dirLen) == 0) {
126         /* substrings match; path must match dir or be subdirectory */
127         if (pathNorm[dirLen] == '\0' || pathNorm[dirLen] == '/') {
128             inDir = 1;
129         }
130     }
131 #endif /* AFS_NT40_ENV */
132     return inDir;
133 }
134
135 int
136 AuthOkay(struct rx_call *call, char *name)
137 {
138     int i;
139     rxkad_level level;
140     afs_int32 code;
141     int matches;
142
143     /* Must be in 'UserList' to use */
144     if (!afsconf_SuperUser(cdir, call, NULL))
145         return 0;
146
147     if (rx_SecurityClassOf(rx_ConnectionOf(call)) == 2) {
148         code = rxkad_GetServerInfo(call->conn, &level, 0, 0, 0, 0, 0);
149         if (code)
150             return 0;
151     } else
152         level = 0;
153
154     matches = 0;
155     for (i = 0; i < nDirs; i++) {
156         if (PathInDirectory(dirName[i], name)) {
157             if (dirLevel[i] > level)
158                 return 0;
159             matches++;
160             /* keep searching in case there's a more restrictive subtree
161              * specified later. */
162         }
163     }
164     if (nDirs && !matches)
165         return 0;               /* if dirs spec., name must match */
166     return 1;                   /* okay or no dirs */
167 }
168
169 int
170 osi_audit()
171 {
172 /* this sucks but it works for now.
173 */
174     return 0;
175 }
176
177 #ifndef AFS_NT40_ENV
178 #include "AFS_component_version_number.c"
179 #endif
180
181 int
182 main(int argc, char *argv[])
183 {
184     struct rx_securityClass *securityObjects[3];
185     struct rx_service *service;
186     afs_uint32 host = htonl(INADDR_ANY);
187
188     int a = 0;
189     rxkad_level level;
190     rxkad_level newLevel;
191
192 #ifdef  AFS_AIX32_ENV
193     /*
194      * The following signal action for AIX is necessary so that in case of a 
195      * crash (i.e. core is generated) we can include the user's data section 
196      * in the core dump. Unfortunately, by default, only a partial core is
197      * generated which, in many cases, isn't too useful.
198      */
199     struct sigaction nsa;
200
201     sigemptyset(&nsa.sa_mask);
202     nsa.sa_handler = SIG_DFL;
203     nsa.sa_flags = SA_FULLDUMP;
204     sigaction(SIGABRT, &nsa, NULL);
205     sigaction(SIGSEGV, &nsa, NULL);
206 #endif
207
208     whoami = argv[0];
209
210 #ifdef AFS_NT40_ENV
211     /* dummy signal call to force afsprocmgmt.dll to load on NT */
212     signal(SIGUSR1, SIG_DFL);
213 #endif
214
215     /* Initialize dirpaths */
216     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
217 #ifdef AFS_NT40_ENV
218         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
219 #endif
220         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
221                 argv[0]);
222         exit(2);
223     }
224     nDirs = 0;
225     level = rxkad_clear;
226
227     if (argc == 1)              /* no arguments */
228         goto usage;
229
230     /* support help flag */
231     if (strcmp("-help", argv[1]) == 0)
232         goto usage;
233     if (strcmp("help", argv[1]) == 0)
234         goto usage;
235
236     for (a = 1; a < argc; a++) {
237         if (argv[a][0] == '-') {        /* parse options */
238             if (strcmp(argv[a], "-rxbind") == 0) {
239                 rxBind = 1;
240                 continue;
241             } else {
242                 char arg[256];
243                 lcstring(arg, argv[a], sizeof(arg));
244                 newLevel = rxkad_StringToLevel(&argv[a][1]);
245                 if (newLevel != -1) {
246                     level = newLevel;   /* set new level */
247                     continue;
248                 }
249             }
250           usage:
251             Quit("Usage: upserver [<directory>+] [-crypt <directory>+] [-clear <directory>+] [-auth <directory>+] [-rxbind] [-help]\n");
252         } else {
253             int dirlen;
254             if (nDirs >= sizeof(dirName) / sizeof(dirName[0]))
255                 Quit("Too many dirs");
256             dirlen = strlen(argv[a]);
257             if (AddObject(&dirName[nDirs], argv[a])) {
258                 printf("%s: Unable to export dir %s. Skipping\n", whoami,
259                        argv[a]);
260                 continue;
261             }
262             dirLevel[nDirs] = level;    /* remember current level */
263             nDirs++;
264         }
265     }
266
267     if (nDirs == 0) {           /* Didn't find any directories to export */
268         printf("%s: No directories to export. Quitting\n", whoami);
269         exit(1);
270     }
271
272     cdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH);
273     if (cdir == 0) {
274         fprintf(stderr, "Can't get server configuration info (%s)\n",
275                 AFSDIR_SERVER_ETC_DIRPATH);
276         exit(1);
277     }
278
279     if (rxBind) {
280         afs_int32 ccode;
281         if (AFSDIR_SERVER_NETRESTRICT_FILEPATH || 
282             AFSDIR_SERVER_NETINFO_FILEPATH) {
283             char reason[1024];
284             ccode = parseNetFiles(SHostAddrs, NULL, NULL,
285                                            ADDRSPERSITE, reason,
286                                            AFSDIR_SERVER_NETINFO_FILEPATH,
287                                            AFSDIR_SERVER_NETRESTRICT_FILEPATH);
288         } else 
289         {
290             ccode = rx_getAllAddr(SHostAddrs, ADDRSPERSITE);
291         }
292         if (ccode == 1) 
293             host = SHostAddrs[0];
294     }
295
296     /* Initialize Rx, telling it port number this server will use for its
297      * single service */
298     if (rx_InitHost(host, htons(AFSCONF_UPDATEPORT)) < 0)
299         Quit("rx_init");
300
301     /* Create a single security object, in this case the null security object,
302      * for unauthenticated connections, which will be used to control security
303      * on connections made to this server. */
304
305     /* WHAT A JOKE!  Let's use rxkad at least so we know who we're talking to,
306      * then sometimes require full encryption. */
307
308     /* rxnull and rxvab are no longer supported */
309     securityObjects[0] = rxnull_NewServerSecurityObject();
310
311     securityObjects[1] = (struct rx_securityClass *)0;
312
313     securityObjects[2] =
314         rxkad_NewServerSecurityObject(rxkad_clear, cdir, afsconf_GetKey, 0);
315     if (securityObjects[2] == (struct rx_securityClass *)0)
316         Quit("rxkad_NewServerSecurityObject");
317
318     /* Instantiate a single UPDATE service.  The rxgen-generated procedure
319      * which is called to decode requests is passed in here
320      * (UPDATE_ExecuteRequest). */
321     service =
322         rx_NewServiceHost(host, 0, UPDATE_SERVICEID, "UPDATE", securityObjects,
323                           3, UPDATE_ExecuteRequest);
324     if (service == (struct rx_service *)0)
325         Quit("rx_NewService");
326     rx_SetMaxProcs(service, 2);
327
328     /* allow super users to manage RX statistics */
329     rx_SetRxStatUserOk(update_rxstat_userok);
330
331     rx_StartServer(1);          /* Donate this process to the server process pool */
332     Quit("StartServer returned?");
333     return 0;
334 }
335
336 /* fetch the file name and send it to the remote requester specified by call */
337
338 int
339 UPDATE_FetchFile(struct rx_call *call, char *name)
340 {
341     int fd = -1;
342     int error = 0;
343     struct stat status;
344     char *reqObject;
345
346     /* construct a local path from a canonical (wire-format) path */
347     if ((error = ConstructLocalPath(name, "/", &reqObject))) {
348         afs_com_err(whoami, error, "Unable to construct local path");
349         return UPDATE_ERROR;
350     }
351
352     if (!AuthOkay(call, reqObject)) {
353         error = UPDATE_ERROR;
354     } else {
355         fd = open(reqObject, O_RDONLY, 0);
356         if (fd < 0 || fstat(fd, &status) < 0) {
357             printf("Failed to open %s\n", reqObject);
358             error = UPDATE_ERROR;
359         }
360         if (!error)
361             error = update_SendFile(fd, call, &status);
362         if (fd >= 0)
363             close(fd);
364     }
365     free(reqObject);
366     return error;
367 }
368
369 /* fetch dir info about directory name and send it to remote host associated
370   with call. */
371 int
372 UPDATE_FetchInfo(struct rx_call *call, char *name)
373 {
374     int error = 0;
375     struct stat status;
376     char *reqObject;
377
378     /* construct a local path from a canonical (wire-format) path */
379     if ((error = ConstructLocalPath(name, "/", &reqObject))) {
380         afs_com_err(whoami, error, "Unable to construct local path");
381         return UPDATE_ERROR;
382     }
383
384     if (!AuthOkay(call, reqObject)) {
385         error = UPDATE_ERROR;
386     } else {
387         /* we only need to stat the obj, not open it. */
388         if (stat(reqObject, &status) < 0) {
389             printf("Failed to open %s\n", reqObject);
390             error = UPDATE_ERROR;
391         }
392         if ((status.st_mode & S_IFMT) != S_IFDIR) {
393             printf(" file %s is not a directory \n", reqObject);
394             error = -1;
395         }
396
397         if (!error)
398             error = update_SendDirInfo(reqObject, call, &status, name);
399     }
400     free(reqObject);
401     return error;
402 }
403
404 static int
405 Quit(msg, a, b)
406      char *msg;
407 {
408     fprintf(stderr, msg, a, b);
409     exit(1);
410 }
411
412 int
413 update_SendFile(register int fd, register struct rx_call *call, register 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 = (char *)malloc(blockSize);
434     if (!buffer) {
435         printf("malloc failed\n");
436         return UPDATE_ERROR;
437     }
438     tlen = htonl(length);
439     rx_Write(call, &tlen, sizeof(afs_int32));   /* send length on fetch */
440     while (!error && length) {
441         register 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      register struct rx_call *call,     /* rx call */
463      register 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[MAXSIZE], dirInfoFile[MAXSIZE];
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[MAXSIZE];
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 }