uspace/srv/net/tcp/segment.c

   1 /*
   2  * Copyright (c) 2011 Jiri Svoboda
   3  * 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  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup tcp
  30  * @{
  31  */
  32
  33 /**
  34  * @file Segment processing
  35  */
  36
  37 #include <io/log.h>
  38 #include <mem.h>
  39 #include <stdlib.h>
  40 #include "segment.h"
  41 #include "seq_no.h"
  42 #include "tcp_type.h"
  43
  44 /** Alocate new segment structure. */
  45 tcp_segment_t *tcp_segment_new(void)
  46 {
  47         return calloc(1, sizeof(tcp_segment_t));
  48 }
  49
  50 /** Delete segment. */
  51 void tcp_segment_delete(tcp_segment_t *seg)
  52 {
  53         free(seg);
  54 }
  55
  56 /** Create duplicate of segment.
  57  *
  58  * @param seg   Segment
  59  * @return      Duplicate segment
  60  */
  61 tcp_segment_t *tcp_segment_dup(tcp_segment_t *seg)
  62 {
  63         tcp_segment_t *scopy;
  64         size_t tsize;
  65
  66         scopy = tcp_segment_new();
  67         if (scopy == NULL)
  68                 return NULL;
  69
  70         scopy->ctrl = seg->ctrl;
  71         scopy->seq = seg->seq;
  72         scopy->ack = seg->ack;
  73         scopy->len = seg->len;
  74         scopy->wnd = seg->wnd;
  75         scopy->up = seg->up;
  76
  77         tsize = tcp_segment_text_size(seg);
  78         scopy->data = calloc(tsize, 1);
  79         if (scopy->data == NULL) {
  80                 free(scopy);
  81                 return NULL;
  82         }
  83
  84         memcpy(scopy->data, seg->data, tsize);
  85         scopy->dfptr = scopy->data;
  86
  87         return scopy;
  88 }
  89
  90 /** Create a control-only segment.
  91  *
  92   * @return     Segment
  93  */
  94 tcp_segment_t *tcp_segment_make_ctrl(tcp_control_t ctrl)
  95 {
  96         tcp_segment_t *seg;
  97
  98         seg = tcp_segment_new();
  99         if (seg == NULL)
 100                 return NULL;
 101
 102         seg->ctrl = ctrl;
 103         seg->len = seq_no_control_len(ctrl);
 104
 105         return seg;
 106 }
 107
 108 /** Create an RST segment.
 109  *
 110  * @param seg   Segment we are replying to
 111  * @return      RST segment
 112  */
 113 tcp_segment_t *tcp_segment_make_rst(tcp_segment_t *seg)
 114 {
 115         tcp_segment_t *rseg;
 116
 117         rseg = tcp_segment_new();
 118         if (rseg == NULL)
 119                 return NULL;
 120
 121         if ((seg->ctrl & CTL_ACK) == 0) {
 122                 rseg->ctrl = CTL_RST | CTL_ACK;
 123                 rseg->seq = 0;
 124                 rseg->ack = seg->seq + seg->len;
 125         } else {
 126                 rseg->ctrl = CTL_RST;
 127                 rseg->seq = seg->ack;
 128         }
 129
 130         return rseg;
 131 }
 132
 133 /** Create a control segment.
 134  *
 135   * @return     Segment
 136  */
 137 tcp_segment_t *tcp_segment_make_data(tcp_control_t ctrl, void *data,
 138     size_t size)
 139 {
 140         tcp_segment_t *seg;
 141
 142         seg = tcp_segment_new();
 143         if (seg == NULL)
 144                 return NULL;
 145
 146         seg->ctrl = ctrl;
 147         seg->len = seq_no_control_len(ctrl) + size;
 148
 149         seg->dfptr = seg->data = malloc(size);
 150         if (seg->dfptr == NULL) {
 151                 free(seg);
 152                 return NULL;
 153         }
 154
 155         memcpy(seg->data, data, size);
 156
 157         return seg;
 158 }
 159
 160
 161 /** Trim segment from left and right by the specified amount.
 162  *
 163  * Trim any text or control to remove the specified amount of sequence
 164  * numbers from the left (lower sequence numbers) and right side
 165  * (higher sequence numbers) of the segment.
 166  *
 167  * @param seg           Segment, will be modified in place
 168  * @param left          Amount of sequence numbers to trim from the left
 169  * @param right         Amount of sequence numbers to trim from the right
 170  */
 171 void tcp_segment_trim(tcp_segment_t *seg, uint32_t left, uint32_t right)
 172 {
 173         uint32_t t_size;
 174
 175         assert(left + right <= seg->len);
 176
 177         /* Special case, entire segment trimmed from left */
 178         if (left == seg->len) {
 179                 seg->seq = seg->seq + seg->len;
 180                 seg->len = 0;
 181                 return;
 182         }
 183
 184         /* Special case, entire segment trimmed from right */
 185         if (right == seg->len) {
 186                 seg->len = 0;
 187                 return;
 188         }
 189
 190         /* General case */
 191
 192         t_size = tcp_segment_text_size(seg);
 193
 194         if (left > 0 && (seg->ctrl & CTL_SYN) != 0) {
 195                 /* Trim SYN */
 196                 seg->ctrl &= ~CTL_SYN;
 197                 seg->seq++;
 198                 seg->len--;
 199                 left--;
 200         }
 201
 202         if (right > 0 && (seg->ctrl & CTL_FIN) != 0) {
 203                 /* Trim FIN */
 204                 seg->ctrl &= ~CTL_FIN;
 205                 seg->len--;
 206                 right--;
 207         }
 208
 209         if (left > 0 || right > 0) {
 210                 /* Trim segment text */
 211                 assert(left + right <= t_size);
 212
 213                 seg->data += left;
 214                 seg->len -= left + right;
 215         }
 216 }
 217
 218 /** Copy out text data from segment.
 219  *
 220  * Data is copied from the beginning of the segment text up to @a size bytes.
 221  * @a size must not be greater than the size of the segment text, but
 222  * it can be less.
 223  *
 224  * @param seg   Segment
 225  * @param buf   Destination buffer
 226  * @param size  Size of destination buffer
 227  */
 228 void tcp_segment_text_copy(tcp_segment_t *seg, void *buf, size_t size)
 229 {
 230         assert(size <= tcp_segment_text_size(seg));
 231         memcpy(buf, seg->data, size);
 232 }
 233
 234 /** Return number of bytes in segment text.
 235  *
 236  * @param seg   Segment
 237  * @return      Number of bytes in segment text
 238  */
 239 size_t tcp_segment_text_size(tcp_segment_t *seg)
 240 {
 241         return seg->len - seq_no_control_len(seg->ctrl);
 242 }
 243
 244 /** Dump segment contents to log.
 245  *
 246  * @param seg   Segment
 247  */
 248 void tcp_segment_dump(tcp_segment_t *seg)
 249 {
 250         log_msg(LOG_DEFAULT, LVL_DEBUG2, "Segment dump:");
 251         log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ctrl = %u", (unsigned)seg->ctrl);
 252         log_msg(LOG_DEFAULT, LVL_DEBUG2, " - seq = % " PRIu32, seg->seq);
 253         log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ack = % " PRIu32, seg->ack);
 254         log_msg(LOG_DEFAULT, LVL_DEBUG2, " - len = % " PRIu32, seg->len);
 255         log_msg(LOG_DEFAULT, LVL_DEBUG2, " - wnd = % " PRIu32, seg->wnd);
 256         log_msg(LOG_DEFAULT, LVL_DEBUG2, " - up = % " PRIu32, seg->up);
 257 }
 258
 259 /**
 260  * @}
 261  */