kernel/core/net/tcp.c

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