kernel/core/net/tcp.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2010  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   6  *
   7  *  This program is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 #include <system.h>
  23 #include <string.h>
  24 #include <dev.h>
  25 #include <net/eth.h>
  26 #include <net/net.h>
  27 #include <net/if.h>
  28 #include <net/packet.h>
  29 #include <net/ip.h>
  30 #include <net/tcp.h>
  31 #include <net/socket.h>
  32 #include <mutex.h>
  33 #include <errno.h>
  34 #include <fd.h>
  35
  36 /* Mutex for socket function */
  37 MUTEX_CREATE (mutex_tcp_accept);
  38 MUTEX_CREATE (mutex_tcp_read_cache);
  39
  40 extern netif_t netif_list;
  41
  42 proto_tcp_conn_t proto_tcp_conn_list;
  43 proto_tcp_backlog_t proto_tcp_backlog_list;
  44
  45 static unsigned short proto_tcp_dup;
  46 static unsigned proto_tcp_seq;
  47 static proto_ip_t proto_ip_prealloc;
  48 static proto_tcp_t proto_tcp_prealloc;
  49 static packet_t packet_prealloc;
  50 static char buf_tcp_prealloc[NET_PACKET_MTU + sizeof (proto_tcp_t) + 1];
  51
  52 /* prototype */
  53 proto_tcp_conn_t *net_proto_tcp_conn_check (net_ipv4 ip_source, net_port port_source, net_ipv4 ip_dest, net_port port_dest, unsigned char *ret);
  54 int net_proto_tcp_conn_add (fd_t *fd);
  55 int net_proto_tcp_conn_set (proto_tcp_conn_t *conn, netif_t *eth, net_port port_source, net_ipv4 ip_dest, net_port port_dest);
  56 int net_proto_tcp_conn_estabilish (proto_tcp_conn_t *conn, netif_t *eth, net_ipv4 ip_dest, net_port port_dest);
  57 int net_proto_tcp_conn_estabilish_reply (proto_tcp_conn_t *conn, proto_ip_t *ip_old, proto_tcp_t *tcp_old);
  58 int net_proto_tcp_read_cache (proto_tcp_conn_t *conn, char *data, unsigned len);
  59 int net_proto_tcp_read_ok (proto_tcp_conn_t *conn, proto_ip_t *ip_old, proto_tcp_t *tcp_old, unsigned len);
  60 int net_proto_tcp_write (netif_t *eth, net_ipv4 dest, proto_tcp_t *tcp, char *data, unsigned len);
  61 int net_proto_tcp_write_data (proto_tcp_conn_t *conn, char *data, unsigned len);
  62 int net_proto_tcp_write_data_ok (proto_tcp_conn_t *conn, proto_ip_t *ip_old, proto_tcp_t *tcp_old);
  63 int net_proto_tcp_conn_disconnected (proto_tcp_conn_t *conn, proto_ip_t *ip_old, proto_tcp_t *tcp_old);
  64 int net_proto_tcp_conn_close (proto_tcp_conn_t *conn);
  65 unsigned net_proto_tcp_conn_del (proto_tcp_conn_t *conn);
  66 proto_tcp_conn_t *net_proto_tcp_conn_find (int fd);
  67 int net_proto_tcp_backlog_add (proto_tcp_conn_t *conn, net_ipv4 ip, net_port port, unsigned seq);
  68 int net_proto_tcp_conn_invite (proto_tcp_conn_t *conn, net_ipv4 ip, net_port port, unsigned seq);
  69
  70 /** TCP protocol
  71  *  User-friendly socket functions
  72  */
  73 int net_proto_tcp_socket (fd_t *fd)
  74 {
  75         return net_proto_tcp_conn_add (fd);
  76 }
  77
  78 extern unsigned long timer_ticks;
  79 int net_proto_tcp_connect (int fd, sockaddr_in *addr)
  80 {
  81         int ret = -1;
  82
  83         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
  84
  85         if (!conn)
  86                 return -1;
  87
  88         netif_t *netif;
  89         for (netif = netif_list.next; netif != &netif_list; netif = netif->next) {
  90                 ret = net_proto_tcp_conn_estabilish (conn, netif, addr->sin_addr, addr->sin_port);
  91
  92                 unsigned long stime = timer_ticks;
  93
  94                 /* blocking mode */
  95                 if (!(conn->flags & O_NONBLOCK)) {
  96                         if (!ret)
  97                                 return -1;
  98
  99                         for (;;) {
 100                                 schedule ();
 101
 102                                 /* timeout for 8s */
 103                                 if ((stime+8000) < timer_ticks)
 104                                         return -1;
 105
 106                                 if (conn->state == PROTO_TCP_CONN_STATE_ESTABILISHED)
 107                                         break;
 108
 109                                 /* when connection cant be accepted succefully first time, try it again */
 110                                 if (conn->state == PROTO_TCP_CONN_STATE_ESTABILISHERROR) {
 111                                         ret = net_proto_tcp_conn_estabilish (conn, netif, addr->sin_addr, addr->sin_port);
 112                                         conn->state = PROTO_TCP_CONN_STATE_ESTABILISH;
 113                                 }
 114                         }
 115                 } else
 116                 /* non-blocking mode */
 117                         return -1;
 118
 119                 ret = 0;
 120         }
 121
 122         return ret;
 123 }
 124
 125 int net_proto_tcp_send (int fd, char *msg, unsigned size)
 126 {
 127         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
 128
 129         if (!conn)
 130                 return -1;
 131
 132         unsigned len = size;
 133
 134         unsigned mtu_tcp = NET_PACKET_MTU - sizeof (proto_tcp_t) - sizeof (net_ipv4) - 16;
 135
 136 check:
 137         if (size > mtu_tcp) {
 138                 int r = net_proto_tcp_send (fd, msg, mtu_tcp);
 139
 140                 if (r <= 0)
 141                         return r;
 142
 143                 msg += mtu_tcp;
 144                 size -= mtu_tcp;
 145
 146                 goto check;
 147         }
 148
 149         int ret = net_proto_tcp_write_data (conn, msg, size);
 150
 151         if (ret) {
 152                 unsigned long stime = timer_ticks;
 153
 154                 /* blocking mode */
 155                 if (!(conn->flags & O_NONBLOCK)) {
 156                         while (conn->state != PROTO_TCP_CONN_STATE_READY) {
 157                                 /* timeout 350ms */
 158                                 if ((stime+350) < timer_ticks)
 159                                         return -1;
 160
 161                                 schedule ();
 162                         }
 163                 } else {
 164
 165                 /* non-blocking mode */
 166                 /* TODO: ? */
 167                 //#ifdef TEST
 168                         while (conn->state != PROTO_TCP_CONN_STATE_READY) {
 169                                 /* timeout 100ms */
 170                                 if ((stime+100) < timer_ticks)
 171                                         return 0;
 172
 173                                 schedule ();
 174                         }
 175                 //#endif
 176                 }
 177         }
 178
 179         return len;
 180 }
 181
 182 int net_proto_tcp_recv (int fd, char *msg, unsigned size)
 183 {
 184         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
 185
 186         if (!conn)
 187                 return -3;
 188
 189         int ret = 0;
 190
 191         //kprintf ("recv () - %d\n", fd);
 192
 193         /* blocking mode */
 194         if (!(conn->flags & O_NONBLOCK)) {
 195                 unsigned long stime = timer_ticks;
 196
 197                 while (!conn->len/* || conn->state != PROTO_TCP_CONN_STATE_READY*/) {
 198                         if ((stime+10000) < timer_ticks)
 199                                 return -1;
 200
 201                         if (conn->state == PROTO_TCP_CONN_STATE_CLOSE) {
 202                                 if (net_proto_tcp_conn_del (conn));
 203                                         return -1;
 204                         }
 205
 206                         schedule ();
 207                 }
 208         } else {
 209                 if (conn->state == PROTO_TCP_CONN_STATE_CLOSE) {
 210                         if (net_proto_tcp_conn_del (conn));
 211                                 return -1;
 212                 }
 213
 214                 if (!conn->len)
 215                         return 0;
 216         }
 217
 218         if ((conn->len-conn->offset) > size) {
 219                 memcpy (msg, conn->data+conn->offset, size);
 220                 //printf ("msg11: %d %d\n", conn->offset, size);
 221                 conn->offset += size;
 222
 223                 ret = size;
 224         } else {
 225                 ret = conn->len-conn->offset;
 226
 227                 memcpy (msg, conn->data+conn->offset, conn->len-conn->offset);
 228                 //printf ("msg22: %d %d %d\n", conn->offset, size, conn->len);
 229                 conn->len = 0;
 230                 conn->offset = 0;
 231
 232                 kfree (conn->data);
 233         }
 234
 235         //kprintf ("recv () - %d -- DATA: %d : %d\n", fd, ret, size);
 236
 237         return ret;
 238 }
 239
 240 int net_proto_tcp_close (int fd)
 241 {
 242         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
 243
 244         if (!conn)
 245                 return -1;
 246
 247         if (conn->state == PROTO_TCP_CONN_STATE_DISCONNECTED)
 248                 return 0;
 249
 250         return net_proto_tcp_conn_close (conn);
 251 }
 252
 253 int net_proto_tcp_fcntl (int fd, int cmd, long arg)
 254 {
 255         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
 256
 257         if (!conn)
 258                 return -1;
 259
 260         switch (cmd) {
 261                 case F_GETFL:
 262                         return conn->flags;
 263                 case F_SETFL:
 264                         conn->flags = arg;
 265                         return 0;
 266         }
 267
 268         return -1;
 269 }
 270
 271 int net_proto_tcp_bind (int fd, sockaddr_in *addr, socklen_t len)
 272 {
 273         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
 274
 275         if (!conn)
 276                 return -1;
 277
 278         netif_t *netif;
 279         for (netif = netif_list.next; netif != &netif_list; netif = netif->next) {
 280                 net_proto_tcp_conn_set (conn, netif, addr->sin_port, 0, 0);
 281                 conn->bind = 1;
 282                 return 0;
 283         }
 284
 285         return -1;
 286 }
 287
 288 int net_proto_tcp_listen (int fd, int backlog)
 289 {
 290         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
 291
 292         if (!conn)
 293                 return -1;
 294
 295         return 0;
 296 }
 297
 298 int net_proto_tcp_accept (int fd, sockaddr_in *addr, socklen_t *addrlen)
 299 {
 300         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
 301
 302         if (!conn)
 303                 return -1;
 304
 305         unsigned i = 0;
 306
 307         proto_tcp_backlog_t *backlog = 0;
 308
 309         /* blocking mode */
 310         if (!(conn->flags & O_NONBLOCK)) {
 311                 while (!i) {
 312                         for (backlog = proto_tcp_backlog_list.next; backlog != &proto_tcp_backlog_list; backlog = backlog->next) {
 313                                 if (backlog->conn == conn) {
 314                                         i = 1;
 315                                         break;
 316                                 }
 317                         }
 318
 319                         schedule ();
 320                 }
 321         } else {
 322         /* non-blocking mode */
 323                 for (backlog = proto_tcp_backlog_list.next; backlog != &proto_tcp_backlog_list; backlog = backlog->next) {
 324                         if (backlog->conn == conn) {
 325                                 i = 1;
 326                                 break;
 327                         }
 328                 }
 329         }
 330
 331         //printf ("accept ()\n");
 332
 333         if (!i)
 334                 return -1;
 335
 336         net_ipv4 ip = backlog->ip;
 337         net_port port = backlog->port;
 338         unsigned seq = backlog->seq;
 339
 340         int ret = net_proto_tcp_conn_invite (conn, ip, port, seq);
 341
 342         /* remove from queue accepted connection */
 343         backlog->next->prev = backlog->prev;
 344         backlog->prev->next = backlog->next;
 345
 346         kfree (backlog);
 347
 348         if (ret < 1)
 349                 return ret;
 350
 351         fd_t *fd_new = fd_create (FD_SOCK);
 352
 353         if (!fd_new)
 354                 return 0;
 355
 356         net_proto_tcp_conn_add (fd_new);
 357
 358         proto_tcp_conn_t *conn_new = net_proto_tcp_conn_find (fd_new->id);
 359
 360         if (!conn_new)
 361                 return -1;
 362
 363         net_proto_tcp_conn_set (conn_new, conn->netif, conn->port_source, conn->netif->ip, port);
 364
 365         conn_new->ip_dest = ip;
 366
 367         addr->sin_addr = ip;
 368         addr->sin_port = port;
 369         addr->sin_family = AF_INET;
 370
 371         /* wait for ACK */
 372         unsigned long stime = timer_ticks;
 373         while (conn_new->state != PROTO_TCP_CONN_STATE_READY) {
 374                 if ((stime+10) < timer_ticks)
 375                         return -1;
 376
 377                 schedule ();
 378         }
 379
 380         return fd_new->id;
 381 }
 382
 383 int net_proto_tcp_select (int readfd, int writefd, int exceptfd)
 384 {
 385         int fd = -1;
 386
 387         if (readfd)
 388                 fd = readfd;
 389         else if (writefd)
 390                 fd = writefd;
 391         else if (exceptfd)
 392                 fd = exceptfd;
 393
 394         proto_tcp_conn_t *conn = net_proto_tcp_conn_find (fd);
 395
 396         if (!conn)
 397                 return -1;
 398
 399         /* check for incoming connections */
 400         if (conn->bind) {
 401                 proto_tcp_backlog_t *backlog = 0;
 402
 403                 for (backlog = proto_tcp_backlog_list.next; backlog != &proto_tcp_backlog_list; backlog = backlog->next) {
 404                         if (backlog->conn == conn)
 405                                 return 1;
 406                 }
 407
 408                 return 0;
 409         }
 410
 411         /* Is socket closed ? */
 412         if (conn->state == PROTO_TCP_CONN_STATE_CLOSE)
 413                 return 1;
 414
 415         /* Are some data available ? */
 416         if (conn->len)
 417                 return 1;
 418
 419         return 0;
 420 }
 421
 422 /** TCP protocol
 423  *  Hardcore code - syn, ack, psh, fin, etc :P
 424  */
 425 unsigned net_proto_tcp_handler (packet_t *packet, proto_ip_t *ip, char *buf, unsigned len)
 426 {
 427         proto_tcp_t *tcp = (proto_tcp_t *) buf;
 428
 429         unsigned char ret = 0;
 430
 431         /* First check ip address and ports, that we want this data */
 432         proto_tcp_conn_t *conn = net_proto_tcp_conn_check (ip->ip_dest, tcp->port_dest, ip->ip_source, tcp->port_source, &ret);
 433
 434         if (!conn && ret == 0)
 435                 return 1;
 436
 437         //printf ("tcp->flags: 0x%x, ret: %d, conn: 0x%x, fd: %d\n", tcp->flags, ret, conn, conn->fd);
 438
 439         /* connection from client before accept () */
 440         if (ret == 1) {
 441                 /* client want connect to our server */
 442                 if (tcp->flags == 0x02) {
 443                         mutex_lock (&mutex_tcp_accept);
 444
 445                         unsigned ret = net_proto_tcp_backlog_add (conn, ip->ip_source, tcp->port_source, tcp->seq);
 446
 447                         mutex_unlock (&mutex_tcp_accept);
 448
 449                         return ret;
 450                 }
 451
 452                 return 1;
 453         }
 454
 455         unsigned data_cache = 0;
 456
 457         /* data received */
 458         if (tcp->flags & 0x08) {
 459                 /* needed for calculate real offset from 4bit number */
 460                 unsigned offset = tcp->data_offset * 4;
 461
 462                 /* now calculate accurate length of tcp _data_ */
 463                 unsigned size = swap16 (ip->total_len) - (offset + (ip->head_len*4));
 464                 //kprintf (">>>> %d : %d : %d\n", offset, size, len);
 465                 //mutex_lock (&mutex_tcp_read_cache);
 466                 net_proto_tcp_read_cache (conn, buf+offset, size);
 467                 //mutex_unlock (&mutex_tcp_read_cache);
 468                 /* send ack */
 469                 net_proto_tcp_read_ok (conn, ip, tcp, size);
 470
 471                 data_cache = 1;
 472         }
 473
 474         /* sended data was delivered succefully / ACK */
 475         if (tcp->flags & 0x10) {
 476                 /* HACK: It is interesting, that no push flag, and there could be some data to read */
 477
 478                 /* needed for calculate real offset from 4bit number */
 479                 unsigned offset = tcp->data_offset * 4;
 480
 481                 /* now calculate accurate length of tcp _data_ */
 482                 unsigned size = swap16 (ip->total_len) - (offset + (ip->head_len*4));
 483
 484                 /* there are data for read */
 485                 if (size) {
 486                         /* data was cached, so no need cache it again */
 487                         if (!data_cache) {
 488                                 //kprintf (">>>>2 %d : %d : %d\n", offset, size, len);
 489                                 mutex_lock (&mutex_tcp_read_cache);
 490                                 net_proto_tcp_read_cache (conn, buf+offset, size);
 491                                 mutex_unlock (&mutex_tcp_read_cache);
 492                                 /* send ack */
 493                                 net_proto_tcp_read_ok (conn, ip, tcp, size);
 494                         }
 495                 } else {
 496                         /* when data are'nt available, lets normal work - acknowledgement */
 497                         if (conn->state == PROTO_TCP_CONN_STATE_ESTABILISH) {
 498                                 conn->state = PROTO_TCP_CONN_STATE_ESTABILISHERROR;
 499                                 net_proto_tcp_write_data_ok (conn, ip, tcp);
 500                         } else
 501                                 net_proto_tcp_write_data_ok (conn, ip, tcp);
 502                 }
 503         }
 504
 505         /* connection estabilish respond */
 506         if (tcp->flags == 0x12) {
 507                 return net_proto_tcp_conn_estabilish_reply (conn, ip, tcp);
 508         }
 509
 510         /* another side close connection */
 511         if (tcp->flags & 0x01) {
 512                 DPRINT (DBG_NET | DBG_SOCKET | DBG_TCP, "TCP -> fd %d connection closed by remote host", conn->fd);
 513                 net_proto_tcp_conn_disconnected (conn, ip, tcp);                        // FIXME: problem in server with hangind the whole program
 514         }
 515
 516         /* another side close connection */
 517         if (tcp->flags & 0x04) {
 518                 DPRINT (DBG_NET | DBG_SOCKET | DBG_TCP, "TCP -> fd %d connection reseted by peer", conn->fd);
 519                 net_proto_tcp_conn_disconnected (conn, ip, tcp);
 520         }
 521
 522         return 1;
 523 }
 524
 525 int net_proto_tcp_read_cache (proto_tcp_conn_t *conn, char *data, unsigned len)
 526 {
 527         if (!data || !conn || !len)
 528                 return 0;
 529
 530         if (!conn->len) {
 531                 conn->data = (char *) kmalloc (sizeof (char) * (len + 1));
 532
 533                 memcpy (conn->data, data, len);
 534         } else {
 535                 char *newdata = (char *) kmalloc (sizeof (char) * (conn->len + len + 1));
 536
 537                 if (!newdata)
 538                         return 0;
 539
 540                 memcpy (newdata, conn->data, conn->len);
 541                 memcpy (newdata+conn->len, data, len);
 542
 543                 kfree (conn->data);
 544
 545                 conn->data = newdata;
 546         }
 547
 548         if (!conn->data)
 549                 return -1;
 550
 551         //kprintf ("DATA: %d - #'%s'#\n", len, data);
 552
 553         conn->len += len;
 554
 555         conn->data[conn->len] = '\0';
 556
 557         return conn->len;
 558 }
 559
 560 int net_proto_tcp_read_ok (proto_tcp_conn_t *conn, proto_ip_t *ip_old, proto_tcp_t *tcp_old, unsigned len)
 561 {
 562         if (!ip_old || !tcp_old || !conn)
 563                 return 0;
 564
 565         proto_tcp_t *tcp = (proto_tcp_t *) kmalloc (sizeof (proto_tcp_t));
 566
 567         if (!tcp)
 568                 return 0;
 569
 570         tcp->port_source = conn->port_source; // increase client port too
 571         tcp->port_dest = conn->port_dest;
 572
 573         tcp->seq = tcp_old->ack;
 574
 575         /* this small thing did bad work when e.g. 10 10 10 fe get to calculation,
 576                 it returns 10 10 10 08, no 10 10 11 08 */
 577         unsigned seq = swap32 (tcp_old->seq);
 578         seq += len;
 579
 580         tcp->ack = swap32 (seq);
 581
 582         tcp->res = 0;
 583         tcp->data_offset = 5;
 584         tcp->flags = 0x10;
 585         tcp->window = tcp_old->window + swap16 (64);
 586         tcp->checksum = 0;
 587
 588         int ret = net_proto_tcp_write (conn->netif, conn->ip_dest, tcp, 0, 0);
 589
 590         /*if (proto_tcp_dup == tcp_old->checksum) {
 591                 printf ("Duplicated packet :)");
 592                 timer_wait (150);
 593         }*/
 594
 595         if (ret) {
 596                 //printf ("read_ok: seq: 0x%x | ack: 0x%x\n", conn->seq, conn->ack);
 597
 598                 conn->seq = tcp->ack;
 599                 conn->ack = tcp->seq;
 600
 601                 //printf ("read_ok2: seq: 0x%x | ack: 0x%x\n", conn->seq, conn->ack);
 602
 603                 proto_tcp_dup = tcp_old->checksum;
 604
 605                 conn->cross = 1;
 606         }
 607
 608         kfree (tcp);
 609
 610         return ret;
 611 }
 612
 613 int net_proto_tcp_write (netif_t *eth, net_ipv4 dest, proto_tcp_t *tcp, char *data, unsigned len)
 614 {
 615         if (!eth || !tcp)
 616                 return 0;
 617
 618         if (len)
 619                 if (!data)
 620                         return 0;
 621
 622         mac_addr_t mac_dest;
 623         unsigned get = arp_cache_get (dest, &mac_dest);
 624
 625         if (!get) {
 626                 arp_send_request (eth, dest);
 627
 628                 unsigned i = 0;
 629                 /* 100ms for waiting on ARP reply */
 630                 while (i < 100) {
 631                         get = arp_cache_get (dest, &mac_dest);
 632
 633                         if (get)
 634                                 break;
 635
 636                         /* TODO: make better waiting for ARP reply */
 637                         timer_wait (1);
 638
 639                         schedule ();
 640
 641                         i ++;
 642                 }
 643
 644                 if (!get)
 645                         return 0;
 646         }
 647
 648         /* packet header */
 649         packet_t *packet = &packet_prealloc;
 650
 651         if (!packet)
 652                 return 0;
 653
 654         memcpy (&packet->mac_source, eth->dev->dev_addr, 6);
 655         memcpy (&packet->mac_dest, mac_dest, 6);
 656         packet->type = NET_PACKET_TYPE_IPV4;
 657
 658         /* ip layer */
 659         proto_ip_t *ip = &proto_ip_prealloc;
 660
 661         if (!ip)
 662                 return 0;
 663
 664         /* there are some fixed values - yeah it is horrible */
 665         ip->ver = 4;
 666         ip->head_len = 5;
 667
 668         ip->flags = 0;
 669         ip->frag = 0;
 670         ip->ttl = 64;
 671         ip->checksum = 0;
 672         ip->proto = NET_PROTO_IP_TYPE_TCP;
 673         ip->ip_source = eth->ip;
 674         ip->ip_dest = dest;
 675
 676         unsigned l = (tcp->data_offset*4);
 677
 678         /* calculate total length of packet (tcp/ip) */
 679         ip->total_len = swap16 (l+sizeof (proto_tcp_t)+len);
 680
 681         if (len+l > NET_PACKET_MTU + sizeof (proto_tcp_t)) {
 682                 DPRINT (DBG_NET | DBG_SOCKET | DBG_TCP, "TCP -> data lenght is exceed: %d/%d bytes", len+l, NET_PACKET_MTU + sizeof (proto_tcp_t) + 1);
 683                 return 0;
 684         }
 685
 686         char *buf_tcp = (char *) &buf_tcp_prealloc; //(char *) kmalloc ((len+l+1) * sizeof (char));
 687
 688         if (!buf_tcp)
 689                 return 0;
 690
 691         memcpy (buf_tcp, (char *) tcp, l);
 692
 693         if (len)
 694                 memcpy (buf_tcp+l, data, len);
 695
 696 //      buf_tcp[l+len] = '\0';
 697
 698         /* calculate checksum and put it to tcp header */
 699         proto_tcp_t *tcp_ = (proto_tcp_t *) buf_tcp;
 700
 701         tcp_->checksum = checksum16_tcp (eth->ip, dest, buf_tcp, l+len);
 702
 703         /* send tcp header+data to ip layer */
 704         unsigned ret = net_proto_ip_send (eth, packet, ip, (char *) buf_tcp, l+len);
 705
 706         //kfree (buf_tcp);
 707
 708         return ret;
 709 }
 710
 711 int net_proto_tcp_write_data (proto_tcp_conn_t *conn, char *data, unsigned len)
 712 {
 713         if (!conn || !len || !data)
 714                 return 0;
 715
 716         proto_tcp_t *tcp = &proto_tcp_prealloc;
 717
 718         if (!tcp)
 719                 return 0;
 720
 721         tcp->port_source = conn->port_source;
 722         tcp->port_dest = conn->port_dest;
 723
 724         unsigned seq = swap32 (proto_tcp_seq);
 725         seq ++;
 726
 727         //tcp->ack = swap32 (seq);
 728
 729         proto_tcp_seq = swap32 (seq);
 730
 731         if (!conn->cross) {
 732                 tcp->seq = conn->seq;
 733                 tcp->ack = conn->ack;
 734         } else {
 735                 tcp->seq = conn->ack;
 736                 tcp->ack = conn->seq;
 737
 738                 conn->cross = 0;
 739         }
 740
 741 //      printf ("TCP -> seq: 0x%x | ack: 0x%x | proto_seq: 0x%x\n", tcp->seq, tcp->ack, proto_tcp_seq);
 742
 743         tcp->res = 0;
 744         tcp->data_offset = 5;
 745         tcp->flags = 0x18;
 746         tcp->window = swap16 (32768);
 747         tcp->checksum = 0;
 748
 749         int ret = net_proto_tcp_write (conn->netif, conn->ip_dest, tcp, data, len);
 750
 751         if (ret)
 752                 conn->state = PROTO_TCP_CONN_STATE_WAIT;
 753
 754         return ret;
 755 }
 756
 757 int net_proto_tcp_write_data_ok (proto_tcp_conn_t *conn, proto_ip_t *ip_old, proto_tcp_t *tcp_old)
 758 {
 759         if (!ip_old || !tcp_old || !conn)
 760                 return 0;
 761
 762         /* cross - because we change now sides :) */
 763         conn->seq = tcp_old->ack;
 764         conn->ack = tcp_old->seq;
 765
 766 //      printf ("data_ok: seq: 0x%x | ack: 0x%x\n", tcp_old->ack, tcp_old->seq);
 767
 768         conn->state = PROTO_TCP_CONN_STATE_READY;
 769
 770         return 1;
 771 }
 772
 773 /* try connect to server */
 774 int net_proto_tcp_conn_estabilish (proto_tcp_conn_t *conn, netif_t *eth, net_ipv4 ip_dest, net_port port_dest)
 775 {
 776         if (!conn)
 777                 return 0;
 778
 779         proto_tcp_t *tcp = (proto_tcp_t *) kmalloc (sizeof (proto_tcp_t));
 780
 781         if (!tcp)
 782                 return 0;
 783
 784         tcp->port_source = swap16 (netif_port_get ()); // increase client port too
 785         tcp->port_dest = port_dest;
 786
 787         /* setup new connection */
 788         net_proto_tcp_conn_set (conn, eth, tcp->port_source, ip_dest, tcp->port_dest);
 789
 790         tcp->seq = conn->seq;
 791         tcp->ack = conn->ack;
 792
 793         tcp->res = 0;
 794         tcp->data_offset = 5;
 795         tcp->flags = 0x02;
 796         tcp->window = swap16 (32792);
 797         tcp->checksum = 0;
 798
 799         int ret = net_proto_tcp_write (eth, ip_dest, tcp, 0, 0);
 800
 801         kfree (tcp);
 802
 803         if (!ret) {
 804                 net_proto_tcp_conn_del (conn);
 805                 return 0;
 806         }
 807
 808         return 1;
 809 }
 810
 811 int net_proto_tcp_conn_estabilish_reply (proto_tcp_conn_t *conn, proto_ip_t *ip_old, proto_tcp_t *tcp_old)
 812 {
 813         if (!ip_old || !tcp_old || !conn)
 814                 return 0;
 815
 816         proto_tcp_t *tcp = (proto_tcp_t *) kmalloc (sizeof (proto_tcp_t));
 817
 818         if (!tcp)
 819                 return 0;
 820
 821         tcp->port_source = conn->port_source; // increase client port too
 822         tcp->port_dest = conn->port_dest;
 823
 824         tcp->seq = tcp_old->ack;
 825         tcp->ack = tcp_old->seq + swap32 (1);
 826
 827         tcp->res = 0;
 828         tcp->data_offset = 5;
 829         tcp->flags = 0x10;
 830         tcp->window = tcp_old->window + swap16 (64);
 831         tcp->checksum = 0;
 832
 833         int ret = net_proto_tcp_write (conn->netif, conn->ip_dest, tcp, 0, 0);
 834
 835         if (ret) {
 836                 conn->seq = tcp->seq;
 837                 conn->ack = tcp->ack;
 838                 conn->state = PROTO_TCP_CONN_STATE_ESTABILISHED;
 839
 840                 DPRINT (DBG_NET | DBG_SOCKET | DBG_TCP, "TCP -> fd %d connected to server succefully\n", conn->fd);
 841         }
 842
 843         kfree (tcp);
 844
 845         return ret;
 846 }
 847
 848 int net_proto_tcp_conn_disconnected (proto_tcp_conn_t *conn, proto_ip_t *ip_old, proto_tcp_t *tcp_old)
 849 {
 850         if (!ip_old || !tcp_old || !conn)
 851                 return 0;
 852
 853         if (conn->state == PROTO_TCP_CONN_STATE_CLOSE)
 854                 return net_proto_tcp_conn_del (conn);
 855
 856         proto_tcp_t *tcp = (proto_tcp_t *) kmalloc (sizeof (proto_tcp_t));
 857
 858         if (!tcp)
 859                 return 0;
 860
 861         tcp->port_source = conn->port_source; // increase client port too
 862         tcp->port_dest = conn->port_dest;
 863
 864         tcp->seq = tcp_old->ack;
 865         tcp->ack = tcp_old->seq + swap32 (1);
 866
 867         tcp->res = 0;
 868         tcp->data_offset = 5;
 869         tcp->flags = 0x10;
 870         tcp->window = tcp_old->window + swap16 (64);
 871         tcp->checksum = 0;
 872
 873         int ret = net_proto_tcp_write (conn->netif, conn->ip_dest, tcp, 0, 0);
 874
 875         kfree (tcp);
 876
 877         if (ret)
 878                 conn->state = PROTO_TCP_CONN_STATE_CLOSE; //ret = net_proto_tcp_conn_del (conn);
 879         else
 880                 return -1;
 881
 882         return ret;
 883 }
 884
 885 int net_proto_tcp_conn_close (proto_tcp_conn_t *conn)
 886 {
 887         return 0;       /* FIXME: close () is faster then send () sometime :-B */
 888
 889         if (!conn)
 890                 return 0;
 891
 892         if (conn->state == PROTO_TCP_CONN_STATE_CLOSE)
 893                 return 0;
 894
 895         proto_tcp_t *tcp = (proto_tcp_t *) kmalloc (sizeof (proto_tcp_t));
 896
 897         if (!tcp)
 898                 return 0;
 899
 900         tcp->port_source = conn->port_source; // increase client port too
 901         tcp->port_dest = conn->port_dest;
 902
 903         tcp->seq = conn->seq;
 904         tcp->ack = conn->ack;
 905
 906         tcp->res = 0;
 907         tcp->data_offset = 5;
 908         tcp->flags = 0x11;
 909         tcp->window = swap16 (32832);
 910         tcp->checksum = 0;
 911
 912         int ret = net_proto_tcp_write (conn->netif, conn->ip_dest, tcp, 0, 0);
 913
 914         kfree (tcp);
 915
 916         if (ret)
 917                 conn->state = PROTO_TCP_CONN_STATE_CLOSE;
 918
 919         return ret;
 920 }
 921
 922 /* client wants to connect */
 923 net_proto_tcp_conn_invite (proto_tcp_conn_t *conn, net_ipv4 ip, net_port port, unsigned seq)
 924 {
 925         if (!conn)
 926                 return 0;
 927
 928         proto_tcp_t *tcp = (proto_tcp_t *) kmalloc (sizeof (proto_tcp_t));
 929
 930         if (!tcp)
 931                 return 0;
 932
 933         tcp->port_source = conn->port_source;
 934         tcp->port_dest = port;
 935
 936         tcp->seq = proto_tcp_seq ++;
 937         tcp->ack = seq + swap32 (1);
 938
 939         tcp->res = 0;
 940         tcp->data_offset = 5;
 941         tcp->flags = 0x12;
 942         tcp->window = swap16 (5816);
 943         tcp->checksum = 0;
 944
 945         int ret = net_proto_tcp_write (conn->netif, ip, tcp, 0, 0);
 946
 947         kfree (tcp);
 948
 949         if (ret > 0)
 950                 conn->state = PROTO_TCP_CONN_STATE_READY;
 951         else {
 952                 printf ("wtf ?\n");
 953                 return -1;
 954         }
 955         return 1;
 956 }
 957
 958 /* Create new TCP connection */
 959 int net_proto_tcp_conn_add (fd_t *fd)
 960 {
 961         proto_tcp_conn_t *conn;
 962
 963         /* alloc and init context */
 964         conn = (proto_tcp_conn_t *) kmalloc (sizeof (proto_tcp_conn_t));
 965
 966         if (!conn) {
 967                 errno_set (ENOMEM);
 968                 return -1;
 969         }
 970
 971         memset (conn, 0, sizeof (proto_tcp_conn_t));
 972
 973         conn->flags = 0;
 974         conn->bind = 0;
 975
 976         conn->fd = fd->id;
 977
 978         conn->cross = 0;
 979
 980         /* add into list */
 981         conn->next = &proto_tcp_conn_list;
 982         conn->prev = proto_tcp_conn_list.prev;
 983         conn->prev->next = conn;
 984         conn->next->prev = conn;
 985
 986         return 0;
 987 }
 988
 989 /* Setup new connection */
 990 int net_proto_tcp_conn_set (proto_tcp_conn_t *conn, netif_t *eth, net_port port_source, net_ipv4 ip_dest, net_port port_dest)
 991 {
 992         if (!conn || !eth)
 993                 return 0;
 994
 995         conn->ip_source = eth->ip;
 996         conn->ip_dest = ip_dest;
 997
 998         conn->port_source = port_source;
 999         conn->port_dest = port_dest;
1000
1001         proto_tcp_seq += swap32 (1);
1002
1003         conn->seq = proto_tcp_seq ++;
1004         conn->ack = 0;
1005
1006         conn->state = PROTO_TCP_CONN_STATE_ESTABILISH;
1007
1008         conn->netif = eth;
1009
1010         conn->offset = 0;
1011         conn->len = 0;
1012         conn->data = 0;
1013
1014         return 1;
1015 }
1016
1017 /* Delete existing connection from list */
1018 unsigned net_proto_tcp_conn_del (proto_tcp_conn_t *conn)
1019 {
1020         if (!conn)
1021                 return 0;
1022
1023         conn->state = PROTO_TCP_CONN_STATE_DISCONNECTED;
1024
1025         if (conn->len)
1026                 kfree (conn->data);
1027
1028         conn->len = 0;
1029
1030         conn->next->prev = conn->prev;
1031         conn->prev->next = conn->next;
1032
1033         kfree (conn);
1034
1035         return 1;
1036 }
1037
1038 proto_tcp_conn_t *net_proto_tcp_conn_check (net_ipv4 ip_source, net_port port_source, net_ipv4 ip_dest, net_port port_dest, unsigned char *ret)
1039 {
1040         *ret = 0;
1041         proto_tcp_conn_t *conn = NULL;
1042         proto_tcp_conn_t *conn_ret = NULL;
1043         //printf ("-------------------------\n");
1044         for (conn = proto_tcp_conn_list.next; conn != &proto_tcp_conn_list; conn = conn->next) {
1045                 /*printf ("-> ");
1046                 net_proto_ip_print (conn->ip_source);
1047                 printf (" / ");
1048                 net_proto_ip_print (ip_source);
1049                 printf ("\n2> ");
1050                 net_proto_ip_print (conn->ip_dest);
1051                 printf (" / ");
1052                 net_proto_ip_print (ip_dest);
1053                 printf ("\nporty: %d / %d\n", swap16 (conn->port_source), swap16 (port_source));
1054                 printf ("porty2: %d / %d\n", swap16 (conn->port_dest), swap16 (port_dest));*/
1055
1056                 if (conn->ip_source == ip_source && conn->port_source == port_source) {
1057                         if (conn->ip_dest == ip_dest && conn->port_dest == port_dest) {
1058                                 *ret = 2;
1059                                 return conn;
1060                         }
1061
1062                         *ret = 1;
1063
1064                         conn_ret = conn;
1065                 }
1066         }
1067
1068         if (*ret == 1)
1069                 if (!conn_ret->bind) {
1070                         conn_ret = 0;
1071
1072                         for (conn = proto_tcp_conn_list.next; conn != &proto_tcp_conn_list; conn = conn->next) {
1073                                 if (conn->bind) {
1074                                         if (conn->ip_source == ip_source && conn->port_source == port_source)
1075                                                 conn_ret = conn;
1076                                 }
1077                         }
1078                 }
1079
1080         return conn_ret;
1081 }
1082
1083 proto_tcp_conn_t *net_proto_tcp_conn_find (int fd)
1084 {
1085         proto_tcp_conn_t *conn = NULL;
1086         for (conn = proto_tcp_conn_list.next; conn != &proto_tcp_conn_list; conn = conn->next) {
1087                 if (conn->fd == fd)
1088                         return conn;
1089         }
1090
1091         return 0;
1092 }
1093
1094 /* Create new TCP backlog stamp */
1095 int net_proto_tcp_backlog_add (proto_tcp_conn_t *conn, net_ipv4 ip, net_port port, unsigned seq)
1096 {
1097         if (!conn)
1098                 return 0;
1099
1100         proto_tcp_backlog_t *backlog;
1101
1102         /* alloc and init context */
1103         backlog = (proto_tcp_backlog_t *) kmalloc (sizeof (proto_tcp_backlog_t));
1104
1105         if (!backlog)
1106                 return 0;
1107
1108         backlog->conn = conn;
1109         backlog->ip = ip;
1110         backlog->port = port;
1111         backlog->seq = seq;
1112
1113         /* add into list */
1114         backlog->next = &proto_tcp_backlog_list;
1115         backlog->prev = proto_tcp_backlog_list.prev;
1116         backlog->prev->next = backlog;
1117         backlog->next->prev = backlog;
1118
1119         return conn->fd;
1120 }
1121
1122 /* init of tcp protocol */
1123 unsigned init_net_proto_tcp ()
1124 {
1125         proto_tcp_conn_list.next = &proto_tcp_conn_list;
1126         proto_tcp_conn_list.prev = &proto_tcp_conn_list;
1127
1128         proto_tcp_backlog_list.next = &proto_tcp_backlog_list;
1129         proto_tcp_backlog_list.prev = &proto_tcp_backlog_list;
1130
1131         proto_tcp_dup = 0x0;
1132         proto_tcp_seq = 0x1;
1133
1134         return 1;
1135 }
1136
1137