OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [libc/] [inet/] [rpc/] [rexec.c] - Blame information for rev 1771

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1325 phoenix
/*
2
 * Copyright (c) 1980, 1993
3
 *      The Regents of the University of California.  All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 * 1. Redistributions of source code must retain the above copyright
9
 *    notice, this list of conditions and the following disclaimer.
10
 * 2. Redistributions in binary form must reproduce the above copyright
11
 *    notice, this list of conditions and the following disclaimer in the
12
 *    documentation and/or other materials provided with the distribution.
13
 * 4. Neither the name of the University nor the names of its contributors
14
 *    may be used to endorse or promote products derived from this software
15
 *    without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 */
29
 
30
#define __FORCE_GLIBC
31
#include <features.h>
32
#include <sys/types.h>
33
#include <sys/socket.h>
34
 
35
#include <netinet/in.h>
36
 
37
#include <alloca.h>
38
#include <stdio.h>
39
#include <netdb.h>
40
#include <errno.h>
41
#include <stdlib.h>
42
#include <string.h>
43
#include <unistd.h>
44
 
45
#define SA_LEN(_x)      __libc_sa_len((_x)->sa_family)
46
extern int __libc_sa_len (sa_family_t __af) __THROW;
47
 
48
int     rexecoptions;
49
char    ahostbuf[NI_MAXHOST];
50
extern int ruserpass(const char *host, const char **aname, const char **apass);
51
 
52
int
53
rexec_af(ahost, rport, name, pass, cmd, fd2p, af)
54
        char **ahost;
55
        int rport;
56
        const char *name, *pass, *cmd;
57
        int *fd2p;
58
        sa_family_t af;
59
{
60
        struct sockaddr_storage sa2, from;
61
        struct addrinfo hints, *res0;
62
        const char *orig_name = name;
63
        const char *orig_pass = pass;
64
        u_short port = 0;
65
        int s, timo = 1, s3;
66
        char c;
67
        int gai;
68
        char servbuff[NI_MAXSERV];
69
 
70
        snprintf(servbuff, sizeof(servbuff), "%d", ntohs(rport));
71
        servbuff[sizeof(servbuff) - 1] = '\0';
72
 
73
        memset(&hints, 0, sizeof(hints));
74
        hints.ai_family = af;
75
        hints.ai_socktype = SOCK_STREAM;
76
        hints.ai_flags = AI_CANONNAME;
77
        gai = getaddrinfo(*ahost, servbuff, &hints, &res0);
78
        if (gai){
79
                /* XXX: set errno? */
80
                return -1;
81
        }
82
 
83
        if (res0->ai_canonname){
84
                strncpy(ahostbuf, res0->ai_canonname, sizeof(ahostbuf));
85
                ahostbuf[sizeof(ahostbuf)-1] = '\0';
86
                *ahost = ahostbuf;
87
        }
88
        else{
89
                *ahost = NULL;
90
        }
91
        ruserpass(res0->ai_canonname, &name, &pass);
92
retry:
93
        s = socket(res0->ai_family, res0->ai_socktype, 0);
94
        if (s < 0) {
95
                perror("rexec: socket");
96
                return (-1);
97
        }
98
        if (connect(s, res0->ai_addr, res0->ai_addrlen) < 0) {
99
                if (errno == ECONNREFUSED && timo <= 16) {
100
                        (void) close(s);
101
                        sleep(timo);
102
                        timo *= 2;
103
                        goto retry;
104
                }
105
                perror(res0->ai_canonname);
106
                return (-1);
107
        }
108
        if (fd2p == 0) {
109
                (void) write(s, "", 1);
110
                port = 0;
111
        } else {
112
                char num[32];
113
                int s2, sa2len;
114
 
115
                s2 = socket(res0->ai_family, res0->ai_socktype, 0);
116
                if (s2 < 0) {
117
                        (void) close(s);
118
                        return (-1);
119
                }
120
                listen(s2, 1);
121
                sa2len = sizeof (sa2);
122
                if (getsockname(s2, (struct sockaddr *)&sa2, &sa2len) < 0) {
123
                        perror("getsockname");
124
                        (void) close(s2);
125
                        goto bad;
126
                } else if (sa2len != SA_LEN((struct sockaddr *)&sa2)) {
127
                        __set_errno(EINVAL);
128
                        (void) close(s2);
129
                        goto bad;
130
                }
131
                port = 0;
132
                if (!getnameinfo((struct sockaddr *)&sa2, sa2len,
133
                                 NULL, 0, servbuff, sizeof(servbuff),
134
                                 NI_NUMERICSERV))
135
                        port = atoi(servbuff);
136
                (void) sprintf(num, "%u", port);
137
                (void) write(s, num, strlen(num)+1);
138
                { socklen_t len = sizeof (from);
139
                  s3 = accept(s2, (struct sockaddr *)&from, &len);
140
                  close(s2);
141
                  if (s3 < 0) {
142
                        perror("accept");
143
                        port = 0;
144
                        goto bad;
145
                  }
146
                }
147
                *fd2p = s3;
148
        }
149
        (void) write(s, name, strlen(name) + 1);
150
        /* should public key encypt the password here */
151
        (void) write(s, pass, strlen(pass) + 1);
152
        (void) write(s, cmd, strlen(cmd) + 1);
153
 
154
        /* We don't need the memory allocated for the name and the password
155
           in ruserpass anymore.  */
156
        if (name != orig_name)
157
          free ((char *) name);
158
        if (pass != orig_pass)
159
          free ((char *) pass);
160
 
161
        if (read(s, &c, 1) != 1) {
162
                perror(*ahost);
163
                goto bad;
164
        }
165
        if (c != 0) {
166
                while (read(s, &c, 1) == 1) {
167
                        (void) write(2, &c, 1);
168
                        if (c == '\n')
169
                                break;
170
                }
171
                goto bad;
172
        }
173
        freeaddrinfo(res0);
174
        return (s);
175
bad:
176
        if (port)
177
                (void) close(*fd2p);
178
        (void) close(s);
179
        freeaddrinfo(res0);
180
        return (-1);
181
}
182
 
183
int
184
rexec(ahost, rport, name, pass, cmd, fd2p)
185
        char **ahost;
186
        int rport;
187
        const char *name, *pass, *cmd;
188
        int *fd2p;
189
{
190
        return rexec_af(ahost, rport, name, pass, cmd, fd2p, AF_INET);
191
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.