← Back to branch summary

~ubuntu-branches/ubuntu/karmic/dante/karmic

« back to all changes in this revision

Viewing changes to sockd/lib_protocol.c

  • Committer: Bazaar Package Importer
  • Author(s): Thijs Kinkhorst
  • Date: 2006-10-19 12:09:39 UTC
  • mfrom: (3.1.1 dapper)
  • Revision ID: james.westby@ubuntu.com-20061019120939-t818x24e2tn8be5k
Tags: 1.1.18-2.1
http://bugs.debian.org/393568
* Non-maintainer upload for RC bug.
* Make sure changelogs are installed into all packages (Closes: #393568).

Show diffs side-by-side

added added

removed removed

Lines of Context:
sockd/lib_protocol.c
1
 
/*
2
 
 * Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003
3
 
 *      Inferno Nettverk A/S, Norway.  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. The above copyright notice, this list of conditions and the following
9
 
 *    disclaimer must appear in all copies of the software, derivative works
10
 
 *    or modified versions, and any portions thereof, aswell as in all
11
 
 *    supporting documentation.
12
 
 * 2. All advertising materials mentioning features or use of this software
13
 
 *    must display the following acknowledgement:
14
 
 *      This product includes software developed by
15
 
 *      Inferno Nettverk A/S, Norway.
16
 
 * 3. The name of the author may not be used to endorse or promote products
17
 
 *    derived from this software without specific prior written permission.
18
 
 *
19
 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20
 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21
 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22
 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23
 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24
 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25
 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26
 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27
 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28
 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
 
 *
30
 
 * Inferno Nettverk A/S requests users of this software to return to
31
 
 *
32
 
 *  Software Distribution Coordinator  or  sdc@inet.no
33
 
 *  Inferno Nettverk A/S
34
 
 *  Oslo Research Park
35
 
 *  Gaustadall�en 21
36
 
 *  NO-0349 Oslo
37
 
 *  Norway
38
 
 *
39
 
 * any improvements or extensions that they make and grant Inferno Nettverk A/S
40
 
 * the rights to redistribute these changes.
41
 
 *
42
 
 */
43
 
 
44
 
#include "common.h"
45
 
 
46
 
static const char rcsid[] =
47
 
"$Id: protocol.c,v 1.55 2003/07/01 13:21:31 michaels Exp $";
48
 
 
49
 
unsigned char *
50
 
sockshost2mem(host, mem, version)
51
 
        const struct sockshost_t *host;
52
 
        unsigned char *mem;
53
 
        int version;
54
 
{
55
 
 
56
 
        switch (version) {
57
 
                case SOCKS_V4:
58
 
                case SOCKS_V4REPLY_VERSION:
59
 
                        SASSERTX(host->atype == SOCKS_ADDR_IPV4);
60
 
 
61
 
                        /* DSTPORT */
62
 
                        memcpy(mem, &host->port, sizeof(host->port));
63
 
                        mem += sizeof(host->port);
64
 
 
65
 
                        /* DSTIP */
66
 
                        memcpy(mem, &host->addr.ipv4, sizeof(host->addr.ipv4));
67
 
                        mem += sizeof(host->addr.ipv4);
68
 
 
69
 
                        break;
70
 
 
71
 
                case SOCKS_V5:
72
 
                        /* ATYP */
73
 
                        memcpy(mem, &host->atype, sizeof(host->atype));
74
 
                        mem += sizeof(host->atype);
75
 
 
76
 
                        switch (host->atype) {
77
 
                                case SOCKS_ADDR_IPV4:
78
 
                                        memcpy(mem, &host->addr.ipv4.s_addr,
79
 
                                        sizeof(host->addr.ipv4.s_addr));
80
 
                                        mem += sizeof(host->addr.ipv4.s_addr);
81
 
                                        break;
82
 
 
83
 
                                case SOCKS_ADDR_IPV6:
84
 
                                        memcpy(mem, &host->addr.ipv6, sizeof(host->addr.ipv6));
85
 
                                        mem += sizeof(host->addr.ipv6);
86
 
                                        break;
87
 
 
88
 
                                case SOCKS_ADDR_DOMAIN:
89
 
                                        /* first byte gives length of rest. */
90
 
                                        *mem = (unsigned char)strlen(host->addr.domain);
91
 
                                        memcpy(mem + 1, host->addr.domain, (size_t)*mem);
92
 
                                        mem += *mem + 1;
93
 
                                        break;
94
 
 
95
 
                                default:
96
 
                                        SERRX(host->atype);
97
 
                        }
98
 
 
99
 
                        /* DST.PORT */
100
 
                        memcpy(mem, &host->port, sizeof(host->port));
101
 
                        mem += sizeof(host->port);
102
 
 
103
 
                        break;
104
 
 
105
 
                default:
106
 
                        SERRX(version);
107
 
        }
108
 
 
109
 
        return mem;
110
 
}
111
 
 
112
 
const unsigned char *
113
 
mem2sockshost(host, mem, len, version)
114
 
        struct sockshost_t *host;
115
 
        const unsigned char *mem;
116
 
        size_t len;
117
 
        int version;
118
 
{
119
 
        const char *function = "mem2sockshost()";
120
 
 
121
 
        switch (version) {
122
 
                case SOCKS_V5:
123
 
                        if (len < sizeof(host->atype))
124
 
                                return NULL;
125
 
                        memcpy(&host->atype, mem, sizeof(host->atype));
126
 
                        mem += sizeof(host->atype);
127
 
                        len -= sizeof(host->atype);
128
 
 
129
 
                        switch (host->atype) {
130
 
                                case SOCKS_ADDR_IPV4:
131
 
                                        if (len < sizeof(host->addr.ipv4))
132
 
                                                return NULL;
133
 
                                        memcpy(&host->addr.ipv4, mem, sizeof(host->addr.ipv4));
134
 
                                        mem += sizeof(host->addr.ipv4);
135
 
                                        len -= sizeof(host->addr.ipv4);
136
 
                                        break;
137
 
 
138
 
                                case SOCKS_ADDR_DOMAIN: {
139
 
                                        size_t domainlen = (size_t)*mem;
140
 
 
141
 
                                        mem += sizeof(*mem);
142
 
 
143
 
                                        OCTETIFY(domainlen);
144
 
 
145
 
                                        if (len < domainlen + 1) /* +1 for NUL to be added. */
146
 
                                                return NULL;
147
 
 
148
 
                                        SASSERTX(domainlen < sizeof(host->addr.domain));
149
 
 
150
 
                                        memcpy(host->addr.domain, mem, domainlen);
151
 
                                        host->addr.domain[domainlen] = NUL;
152
 
                                        mem += domainlen;
153
 
                                        len -= domainlen + 1; /* +1 for added NUL. */
154
 
                                        break;
155
 
                                }
156
 
 
157
 
                                case SOCKS_ADDR_IPV6:
158
 
                                        slog(LOG_INFO, "%s: IPv6 not supported", function);
159
 
                                        return NULL;
160
 
 
161
 
                                default:
162
 
                                        slog(LOG_INFO, "%s: unknown atype field: %d",
163
 
                                        function, host->atype);
164
 
                                        return NULL;
165
 
                        }
166
 
 
167
 
                        if (len < sizeof(host->port))
168
 
                                return NULL;
169
 
                        memcpy(&host->port, mem, sizeof(host->port));
170
 
                        mem += sizeof(host->port);
171
 
                        len -= sizeof(host->port);
172
 
 
173
 
                        break;
174
 
 
175
 
                default:
176
 
                        SERRX(version);
177
 
        }
178
 
 
179
 
        return mem;
180
 
}