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