Better length checks.
[tinc] / src / meta.c
1 /*
2     meta.c -- handle the meta communication
3     Copyright (C) 2000-2003 Guus Sliepen <guus@sliepen.eu.org>,
4                   2000-2003 Ivo Timmermans <ivo@o2w.nl>
5
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20     $Id: meta.c,v 1.1.2.44 2003/08/28 21:05:10 guus Exp $
21 */
22
23 #include "system.h"
24
25 #include <openssl/evp.h>
26
27 #include "avl_tree.h"
28 #include "connection.h"
29 #include "logger.h"
30 #include "meta.h"
31 #include "net.h"
32 #include "protocol.h"
33 #include "system.h"
34 #include "utils.h"
35
36 bool send_meta(connection_t *c, const char *buffer, int length)
37 {
38         const char *bufp;
39         int outlen;
40         char outbuf[MAXBUFSIZE];
41         int result;
42
43         cp();
44
45         ifdebug(META) logger(LOG_DEBUG, _("Sending %d bytes of metadata to %s (%s)"), length,
46                            c->name, c->hostname);
47
48         if(c->status.encryptout) {
49                 EVP_EncryptUpdate(c->outctx, outbuf, &outlen, buffer, length);
50                 bufp = outbuf;
51                 length = outlen;
52         } else
53                 bufp = buffer;
54
55         while(length) {
56                 result = send(c->socket, bufp, length, 0);
57                 if(result <= 0) {
58                         if(!errno || errno == EPIPE) {
59                                 ifdebug(CONNECTIONS) logger(LOG_NOTICE, _("Connection closed by %s (%s)"),
60                                                    c->name, c->hostname);
61                         } else if(errno == EINTR)
62                                 continue;
63                         else
64                                 logger(LOG_ERR, _("Sending meta data to %s (%s) failed: %s"), c->name,
65                                            c->hostname, strerror(errno));
66                         return false;
67                 }
68                 bufp += result;
69                 length -= result;
70         }
71         
72         return true;
73 }
74
75 void broadcast_meta(connection_t *from, const char *buffer, int length)
76 {
77         avl_node_t *node;
78         connection_t *c;
79
80         cp();
81
82         for(node = connection_tree->head; node; node = node->next) {
83                 c = node->data;
84
85                 if(c != from && c->status.active)
86                         send_meta(c, buffer, length);
87         }
88 }
89
90 bool receive_meta(connection_t *c)
91 {
92         int oldlen, i;
93         int lenin, reqlen;
94         bool decrypted = false;
95         char inbuf[MAXBUFSIZE];
96
97         cp();
98
99         /* Strategy:
100            - Read as much as possible from the TCP socket in one go.
101            - Decrypt it.
102            - Check if a full request is in the input buffer.
103            - If yes, process request and remove it from the buffer,
104            then check again.
105            - If not, keep stuff in buffer and exit.
106          */
107
108         lenin = recv(c->socket, c->buffer + c->buflen, MAXBUFSIZE - c->buflen, 0);
109
110         if(lenin <= 0) {
111                 if(!lenin || !errno) {
112                         ifdebug(CONNECTIONS) logger(LOG_NOTICE, _("Connection closed by %s (%s)"),
113                                            c->name, c->hostname);
114                 } else if(errno == EINTR)
115                         return true;
116                 else
117                         logger(LOG_ERR, _("Metadata socket read error for %s (%s): %s"),
118                                    c->name, c->hostname, strerror(errno));
119
120                 return false;
121         }
122
123         oldlen = c->buflen;
124         c->buflen += lenin;
125
126         while(lenin) {
127                 /* Decrypt */
128
129                 if(c->status.decryptin && !decrypted) {
130                         EVP_DecryptUpdate(c->inctx, inbuf, &lenin, c->buffer + oldlen, lenin);
131                         memcpy(c->buffer + oldlen, inbuf, lenin);
132                         decrypted = true;
133                 }
134
135                 /* Are we receiving a TCPpacket? */
136
137                 if(c->tcplen) {
138                         if(c->tcplen <= c->buflen) {
139                                 receive_tcppacket(c, c->buffer, c->tcplen);
140
141                                 c->buflen -= c->tcplen;
142                                 lenin -= c->tcplen;
143                                 memmove(c->buffer, c->buffer + c->tcplen, c->buflen);
144                                 oldlen = 0;
145                                 c->tcplen = 0;
146                                 continue;
147                         } else {
148                                 break;
149                         }
150                 }
151
152                 /* Otherwise we are waiting for a request */
153
154                 reqlen = 0;
155
156                 for(i = oldlen; i < c->buflen; i++) {
157                         if(c->buffer[i] == '\n') {
158                                 c->buffer[i] = '\0';    /* replace end-of-line by end-of-string so we can use sscanf */
159                                 reqlen = i + 1;
160                                 break;
161                         }
162                 }
163
164                 if(reqlen) {
165                         c->reqlen = reqlen;
166                         if(!receive_request(c))
167                                 return false;
168
169                         c->buflen -= reqlen;
170                         lenin -= reqlen;
171                         memmove(c->buffer, c->buffer + reqlen, c->buflen);
172                         oldlen = 0;
173                         continue;
174                 } else {
175                         break;
176                 }
177         }
178
179         if(c->buflen >= MAXBUFSIZE) {
180                 logger(LOG_ERR, _("Metadata read buffer overflow for %s (%s)"),
181                            c->name, c->hostname);
182                 return false;
183         }
184
185         c->last_ping_time = now;
186
187         return true;
188 }