aa19267db7a5ee179781fbfd8cc7857eef6873f5
[openafs.git] / src / sgistuff / ta-rauth.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  * This code is used for application programs who want to transfer a
12  * token from the local system to the remote system.
13  */
14 #include <afsconfig.h>
15 #include <afs/param.h>
16
17
18 #include <sys/types.h>
19 #include <sys/param.h>
20 #include <sys/stat.h>
21 #include <sys/ioctl.h>
22 #include <sys/socket.h>
23 #include <sys/file.h>
24 #include <sys/wait.h>
25 #include <sys/time.h>
26
27 #include <netinet/in.h>
28
29 #include <afs/auth.h>
30 #include <afs/cellconfig.h>
31
32 #include <stdio.h>
33 #include <ctype.h>
34 #include <signal.h>
35 #include <strings.h>
36 #if defined(AIX)
37 #include <sys/syslog.h>
38 #else /* defined(AIX) */
39 #include <syslog.h>
40 #endif /* defined(AIX) */
41 #include <errno.h>
42 #include <pwd.h>
43 #include <afs/afsutil.h>
44
45
46 #ifndef RAUTH_PORT
47 #define RAUTH_PORT (601)
48 #endif
49
50  /* ta_rauth provides a single entry point into the remote */
51  /* authentication scheme.  This allows us to simply pass the service */
52  /* name; this routine will in turn obtain whatever remote */
53  /* authentication information necessary and will negotiate with the */
54  /* remote connection.  There are three possible return codes: */
55  /*  (0) There is no remote authentication system; continue without */
56  /*      any authentication. */
57  /*  (1) Remote authentication was negotiated successfully */
58  /*  (-1) Remote authentication failed (but did exist) */
59  /*  (-2) The call could not complete due to internal failure */
60  /*  (-3) The remote connection failed */
61  /* Note that raddr is in *network* byte order! */
62
63 int ta_debug = 0;
64
65 int
66 ta_rauth(s, svc_name, raddr)
67      int s;
68      char *svc_name;
69      struct in_addr raddr;
70 {
71     char localName[64];
72     int code;
73     struct afsconf_dir *tdir;
74     struct ktc_principal tserver;
75     struct ktc_token token;
76     struct sockaddr_in name;
77
78     /* extract the token */
79
80     tdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH);
81     if (!tdir) {
82         if (ta_debug) {
83             syslog(LOG_ERR, "ta_rauth: afsconf_Open failed\n");
84         }
85         return (-2);
86     }
87     code = afsconf_GetLocalCell(tdir, localName, sizeof(localName));
88     if (code) {
89         if (ta_debug) {
90             syslog(LOG_ERR, "ta_rauth: afsconf_GetLocalCell failed\n");
91         }
92         return (-2);
93     }
94     afsconf_Close(tdir);
95
96     strcpy(tserver.cell, localName);
97     strcpy(tserver.name, "afs");
98
99     code = ktc_GetToken(&tserver, &token, sizeof(token), NULL);
100     if (code) {
101         syslog(LOG_WARNING, "ta_rauth: no tokens available");
102         return 0;               /* try port without authentication */
103     }
104
105     name.sin_family = AF_INET;
106     name.sin_port = htons(RAUTH_PORT);
107     name.sin_addr = raddr;
108     if (connect(s, (struct sockaddr *)&name, sizeof(name)) == -1) {
109         extern int errno;
110
111         if (ta_debug) {
112             syslog(LOG_ERR,
113                    "ta_rauth(%s): connect call to (%d:%d) failed=%d\n",
114                    svc_name, raddr.s_addr, htons(RAUTH_PORT), errno);
115             perror("socket");
116         }
117         switch (errno) {
118 #ifdef AFS_AIX_ENV
119             /* On conn failure aix doesn't return any error! */
120         case 0:
121 #endif
122         case ECONNREFUSED:
123             return 0;
124         case ETIMEDOUT:
125         case ENETUNREACH:
126             return -3;
127         default:
128             return -2;
129         }
130     }
131
132     if (outtoken(s, &token, svc_name, localName) == 0) {
133         char result;
134
135         if (read(s, &result, 1) != 1) {
136             syslog(LOG_ERR, "Invalid return from remote authenticator\n");
137             exit(1);
138         }
139         if (result == '0')      /* remote authentication denied */
140             return -1;
141         else                    /* remote authentication allowed */
142             return 1;
143     }
144
145     return (-2);
146 }
147
148 /*
149  * outtoken:
150  *
151  * This routine writes a token on the specified file handle;
152  * The output format for a token is:
153  *
154  *   Field #    Contents         description
155  *    (0)       Service requested char[]
156  *    (1)       Version #        unsigned integer (< 2^32)
157  *    (2)       startTime        unsigned afs_int32 (< 2^32)
158  *    (3)       endTime          unsigned afs_int32 (< 2^32)
159  *    (4)       sessionKey       char[8]
160  *    (5)       kvno             short (< 2^16)
161  *    (6)       ticketLen        unsigned integer (< 2^32)
162  *    (7)       ticket           char[MAXKTCTICKETLEN]
163  *
164  *  All fields are comma separated except (4) and (5) because (4) is fixed
165  *  length; since field (7) is variable length, it is presumed to
166  *  begin after the ',' and to be ticketLen afs_int32.
167  */
168 outtoken(s, token, svc, localName)
169      int s;
170      struct ktc_token *token;
171      char *svc, *localName;
172 {
173     char buf[1024], *bp;
174     int count;
175
176     /* (0) - (3) */
177     sprintf(buf, "%s,%d,%s,%ld,%ld,", svc, 2, localName, token->startTime,
178             token->endTime);
179
180     /* (4) sessionKey */
181     bp = buf + strlen(buf);
182     memcpy(bp, &token->sessionKey, 8);
183     bp += 8;
184
185     /* (5) - (6) */
186     sprintf(bp, "%u,%u,", token->kvno, token->ticketLen);
187
188     /* (7) ticket */
189     bp += strlen(bp);
190     memcpy(bp, token->ticket, token->ticketLen);
191     bp += token->ticketLen;
192
193     if ((count = write(s, buf, (int)(bp - buf))) == -1) {
194         perror("outtoken write");
195         exit(1);
196     }
197     if (ta_debug) {
198         fprintf(stderr, "sent buffer %s\n", buf);
199     }
200     return 0;
201 }