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