source4/lib/stream/packet.c

   1 /*
   2    Unix SMB/CIFS mplementation.
   3
   4    helper layer for breaking up streams into discrete requests
   5
   6    Copyright (C) Andrew Tridgell  2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22 */
  23
  24 #include "includes.h"
  25 #include "dlinklist.h"
  26 #include "lib/events/events.h"
  27 #include "lib/socket/socket.h"
  28 #include "lib/tls/tls.h"
  29 #include "lib/stream/packet.h"
  30
  31
  32 struct packet_context {
  33         packet_callback_fn_t callback;
  34         packet_full_request_fn_t full_request;
  35         packet_error_handler_fn_t error_handler;
  36         DATA_BLOB partial;
  37         uint32_t num_read;
  38         uint32_t initial_read;
  39         struct tls_context *tls;
  40         struct socket_context *sock;
  41         struct event_context *ev;
  42         size_t packet_size;
  43         void *private;
  44         struct fd_event *fde;
  45         BOOL serialise;
  46         BOOL processing;
  47         BOOL recv_disable;
  48         BOOL nofree;
  49
  50         struct send_element {
  51                 struct send_element *next, *prev;
  52                 DATA_BLOB blob;
  53                 size_t nsent;
  54         } *send_queue;
  55 };
  56
  57 /*
  58   initialise a packet receiver
  59 */
  60 struct packet_context *packet_init(TALLOC_CTX *mem_ctx)
  61 {
  62         return talloc_zero(mem_ctx, struct packet_context);
  63 }
  64
  65
  66 /*
  67   set the request callback, called when a full request is ready
  68 */
  69 void packet_set_callback(struct packet_context *pc, packet_callback_fn_t callback)
  70 {
  71         pc->callback = callback;
  72 }
  73
  74 /*
  75   set the error handler
  76 */
  77 void packet_set_error_handler(struct packet_context *pc, packet_error_handler_fn_t handler)
  78 {
  79         pc->error_handler = handler;
  80 }
  81
  82 /*
  83   set the private pointer passed to the callback functions
  84 */
  85 void packet_set_private(struct packet_context *pc, void *private)
  86 {
  87         pc->private = private;
  88 }
  89
  90 /*
  91   set the full request callback. Should return as follows:
  92      NT_STATUS_OK == blob is a full request.
  93      STATUS_MORE_ENTRIES == blob is not complete yet
  94      any error == blob is not a valid
  95 */
  96 void packet_set_full_request(struct packet_context *pc, packet_full_request_fn_t callback)
  97 {
  98         pc->full_request = callback;
  99 }
 100
 101 /*
 102   set a tls context to use. You must either set a tls_context or a socket_context
 103 */
 104 void packet_set_tls(struct packet_context *pc, struct tls_context *tls)
 105 {
 106         pc->tls = tls;
 107 }
 108
 109 /*
 110   set a socket context to use. You must either set a tls_context or a socket_context
 111 */
 112 void packet_set_socket(struct packet_context *pc, struct socket_context *sock)
 113 {
 114         pc->sock = sock;
 115 }
 116
 117 /*
 118   set an event context. If this is set then the code will ensure that
 119   packets arrive with separate events, by creating a immediate event
 120   for any secondary packets when more than one packet is read at one
 121   time on a socket. This can matter for code that relies on not
 122   getting more than one packet per event
 123 */
 124 void packet_set_event_context(struct packet_context *pc, struct event_context *ev)
 125 {
 126         pc->ev = ev;
 127 }
 128
 129 /*
 130   tell the packet layer to serialise requests, so we don't process two requests at once on
 131   one connection. You must have set the event_context
 132 */
 133 void packet_set_serialise(struct packet_context *pc, struct fd_event *fde)
 134 {
 135         pc->serialise = True;
 136         pc->fde = fde;
 137 }
 138
 139 /*
 140   tell the packet layer how much to read when starting a new packet
 141   this ensures it doesn't overread
 142 */
 143 void packet_set_initial_read(struct packet_context *pc, uint32_t initial_read)
 144 {
 145         pc->initial_read = initial_read;
 146 }
 147
 148 /*
 149   tell the packet system not to steal/free blobs given to packet_send()
 150 */
 151 void packet_set_nofree(struct packet_context *pc)
 152 {
 153         pc->nofree = True;
 154 }
 155
 156
 157 /*
 158   tell the caller we have an error
 159 */
 160 static void packet_error(struct packet_context *pc, NTSTATUS status)
 161 {
 162         pc->tls = NULL;
 163         pc->sock = NULL;
 164         if (pc->error_handler) {
 165                 pc->error_handler(pc->private, status);
 166                 return;
 167         }
 168         /* default error handler is to free the callers private pointer */
 169         if (!NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) {
 170                 DEBUG(0,("packet_error on %s - %s\n",
 171                          talloc_get_name(pc->private), nt_errstr(status)));
 172         }
 173         talloc_free(pc->private);
 174         return;
 175 }
 176
 177
 178 /*
 179   tell the caller we have EOF
 180 */
 181 static void packet_eof(struct packet_context *pc)
 182 {
 183         packet_error(pc, NT_STATUS_END_OF_FILE);
 184 }
 185
 186
 187 /*
 188   used to put packets on event boundaries
 189 */
 190 static void packet_next_event(struct event_context *ev, struct timed_event *te,
 191                               struct timeval t, void *private)
 192 {
 193         struct packet_context *pc = talloc_get_type(private, struct packet_context);
 194         if (pc->num_read != 0 && pc->packet_size != 0 &&
 195             pc->packet_size <= pc->num_read) {
 196                 packet_recv(pc);
 197         }
 198 }
 199
 200 /*
 201   call this when the socket becomes readable to kick off the whole
 202   stream parsing process
 203 */
 204 void packet_recv(struct packet_context *pc)
 205 {
 206         size_t npending;
 207         NTSTATUS status;
 208         size_t nread = 0;
 209         DATA_BLOB blob;
 210
 211         if (pc->processing) {
 212                 return;
 213         }
 214
 215         if (pc->recv_disable) {
 216                 EVENT_FD_NOT_READABLE(pc->fde);
 217                 return;
 218         }
 219
 220         if (pc->packet_size != 0 && pc->num_read >= pc->packet_size) {
 221                 goto next_partial;
 222         }
 223
 224         if (pc->packet_size != 0) {
 225                 /* we've already worked out how long this next packet is, so skip the
 226                    socket_pending() call */
 227                 npending = pc->packet_size - pc->num_read;
 228         } else if (pc->initial_read != 0) {
 229                 npending = pc->initial_read - pc->num_read;
 230         } else {
 231                 if (pc->tls) {
 232                         status = tls_socket_pending(pc->tls, &npending);
 233                 } else if (pc->sock) {
 234                         status = socket_pending(pc->sock, &npending);
 235                 } else {
 236                         status = NT_STATUS_CONNECTION_DISCONNECTED;
 237                 }
 238                 if (!NT_STATUS_IS_OK(status)) {
 239                         packet_error(pc, status);
 240                         return;
 241                 }
 242         }
 243
 244         if (npending == 0) {
 245                 packet_eof(pc);
 246                 return;
 247         }
 248
 249         /* possibly expand the partial packet buffer */
 250         if (npending + pc->num_read > pc->partial.length) {
 251                 status = data_blob_realloc(pc, &pc->partial, npending+pc->num_read);
 252                 if (!NT_STATUS_IS_OK(status)) {
 253                         packet_error(pc, status);
 254                         return;
 255                 }
 256         }
 257
 258         if (pc->tls) {
 259                 status = tls_socket_recv(pc->tls, pc->partial.data + pc->num_read,
 260                                          npending, &nread);
 261         } else {
 262                 status = socket_recv(pc->sock, pc->partial.data + pc->num_read,
 263                                      npending, &nread, 0);
 264         }
 265         if (NT_STATUS_IS_ERR(status)) {
 266                 packet_error(pc, status);
 267                 return;
 268         }
 269         if (!NT_STATUS_IS_OK(status)) {
 270                 return;
 271         }
 272
 273         if (nread == 0) {
 274                 packet_eof(pc);
 275                 return;
 276         }
 277
 278         pc->num_read += nread;
 279
 280 next_partial:
 281         if (pc->partial.length != pc->num_read) {
 282                 status = data_blob_realloc(pc, &pc->partial, pc->num_read);
 283                 if (!NT_STATUS_IS_OK(status)) {
 284                         packet_error(pc, status);
 285                         return;
 286                 }
 287         }
 288
 289         /* see if its a full request */
 290         blob = pc->partial;
 291         blob.length = pc->num_read;
 292         status = pc->full_request(pc->private, blob, &pc->packet_size);
 293         if (NT_STATUS_IS_ERR(status)) {
 294                 packet_error(pc, status);
 295                 return;
 296         }
 297         if (!NT_STATUS_IS_OK(status)) {
 298                 return;
 299         }
 300
 301         if (pc->packet_size > pc->num_read) {
 302                 /* the caller made an error */
 303                 DEBUG(0,("Invalid packet_size %u greater than num_read %u\n",
 304                          pc->packet_size, pc->num_read));
 305                 packet_error(pc, NT_STATUS_INVALID_PARAMETER);
 306                 return;
 307         }
 308
 309         /* it is a full request - give it to the caller */
 310         blob = pc->partial;
 311         blob.length = pc->num_read;
 312
 313         if (pc->packet_size < pc->num_read) {
 314                 pc->partial = data_blob_talloc(pc, blob.data + pc->packet_size,
 315                                                pc->num_read - pc->packet_size);
 316                 if (pc->partial.data == NULL) {
 317                         packet_error(pc, NT_STATUS_NO_MEMORY);
 318                         return;
 319                 }
 320                 status = data_blob_realloc(pc, &blob, pc->packet_size);
 321                 if (!NT_STATUS_IS_OK(status)) {
 322                         packet_error(pc, status);
 323                         return;
 324                 }
 325         } else {
 326                 pc->partial = data_blob(NULL, 0);
 327         }
 328         pc->num_read -= pc->packet_size;
 329         pc->packet_size = 0;
 330
 331         if (pc->serialise) {
 332                 EVENT_FD_NOT_READABLE(pc->fde);
 333                 pc->processing = True;
 334         }
 335
 336         status = pc->callback(pc->private, blob);
 337
 338         if (pc->serialise) {
 339                 EVENT_FD_READABLE(pc->fde);
 340                 pc->processing = False;
 341         }
 342
 343         if (!NT_STATUS_IS_OK(status)) {
 344                 packet_error(pc, status);
 345                 return;
 346         }
 347
 348         if (pc->partial.length == 0) {
 349                 return;
 350         }
 351
 352         /* we got multiple packets in one tcp read */
 353         if (pc->ev == NULL) {
 354                 goto next_partial;
 355         }
 356
 357         blob = pc->partial;
 358         blob.length = pc->num_read;
 359
 360         status = pc->full_request(pc->private, blob, &pc->packet_size);
 361         if (NT_STATUS_IS_ERR(status)) {
 362                 packet_error(pc, status);
 363                 return;
 364         }
 365
 366         if (!NT_STATUS_IS_OK(status)) {
 367                 return;
 368         }
 369
 370         event_add_timed(pc->ev, pc, timeval_zero(), packet_next_event, pc);
 371 }
 372
 373
 374 /*
 375   temporarily disable receiving
 376 */
 377 void packet_recv_disable(struct packet_context *pc)
 378 {
 379         EVENT_FD_NOT_READABLE(pc->fde);
 380         pc->recv_disable = True;
 381 }
 382
 383 /*
 384   re-enable receiving
 385 */
 386 void packet_recv_enable(struct packet_context *pc)
 387 {
 388         EVENT_FD_READABLE(pc->fde);
 389         pc->recv_disable = False;
 390         if (pc->num_read != 0 && pc->packet_size >= pc->num_read) {
 391                 event_add_timed(pc->ev, pc, timeval_zero(), packet_next_event, pc);
 392         }
 393 }
 394
 395 /*
 396   trigger a run of the send queue
 397 */
 398 void packet_queue_run(struct packet_context *pc)
 399 {
 400         while (pc->send_queue) {
 401                 struct send_element *el = pc->send_queue;
 402                 NTSTATUS status;
 403                 size_t nwritten;
 404                 DATA_BLOB blob = data_blob_const(el->blob.data + el->nsent,
 405                                                  el->blob.length - el->nsent);
 406
 407                 if (pc->tls) {
 408                         status = tls_socket_send(pc->tls, &blob, &nwritten);
 409                 } else {
 410                         status = socket_send(pc->sock, &blob, &nwritten, 0);
 411                 }
 412                 if (NT_STATUS_IS_ERR(status)) {
 413                         packet_error(pc, NT_STATUS_NET_WRITE_FAULT);
 414                         return;
 415                 }
 416                 if (!NT_STATUS_IS_OK(status)) {
 417                         return;
 418                 }
 419                 el->nsent += nwritten;
 420                 if (el->nsent == el->blob.length) {
 421                         DLIST_REMOVE(pc->send_queue, el);
 422                         talloc_free(el);
 423                 }
 424         }
 425
 426         /* we're out of requests to send, so don't wait for write
 427            events any more */
 428         EVENT_FD_NOT_WRITEABLE(pc->fde);
 429 }
 430
 431 /*
 432   put a packet in the send queue
 433 */
 434 NTSTATUS packet_send(struct packet_context *pc, DATA_BLOB blob)
 435 {
 436         struct send_element *el;
 437         el = talloc(pc, struct send_element);
 438         NT_STATUS_HAVE_NO_MEMORY(el);
 439
 440         DLIST_ADD_END(pc->send_queue, el, struct send_element *);
 441         el->blob = blob;
 442         el->nsent = 0;
 443
 444         /* if we aren't going to free the packet then we must reference it
 445            to ensure it doesn't disappear before going out */
 446         if (pc->nofree) {
 447                 if (!talloc_reference(el, blob.data)) {
 448                         return NT_STATUS_NO_MEMORY;
 449                 }
 450         } else {
 451                 talloc_steal(el, blob.data);
 452         }
 453
 454         EVENT_FD_WRITEABLE(pc->fde);
 455
 456         return NT_STATUS_OK;
 457 }
 458
 459
 460 /*
 461   a full request checker for NBT formatted packets (first 3 bytes are length)
 462 */
 463 NTSTATUS packet_full_request_nbt(void *private, DATA_BLOB blob, size_t *size)
 464 {
 465         if (blob.length < 4) {
 466                 return STATUS_MORE_ENTRIES;
 467         }
 468         *size = 4 + smb_len(blob.data);
 469         if (*size > blob.length) {
 470                 return STATUS_MORE_ENTRIES;
 471         }
 472         return NT_STATUS_OK;
 473 }
 474
 475
 476 /*
 477   work out if a packet is complete for protocols that use a 32 bit network byte
 478   order length
 479 */
 480 NTSTATUS packet_full_request_u32(void *private, DATA_BLOB blob, size_t *size)
 481 {
 482         if (blob.length < 4) {
 483                 return STATUS_MORE_ENTRIES;
 484         }
 485         *size = 4 + RIVAL(blob.data, 0);
 486         if (*size > blob.length) {
 487                 return STATUS_MORE_ENTRIES;
 488         }
 489         return NT_STATUS_OK;
 490 }