kernel/core/net/socket.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
   4  *  Copyright (C) 2008  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 <net/socket.h>
  24 #include <dev.h>
  25 #include <task.h>
  26
  27 socket_t socket_list;
  28
  29 extern fd_t fd_list;
  30 extern unsigned int fd_count;
  31 extern task_t *_curr_task;
  32
  33 socket_t *socket_getbyfd (int fd)
  34 {
  35         socket_t *socket;
  36         for (socket = socket_list.next; socket != &socket_list; socket = socket->next) {
  37                 if (socket->fd == fd)
  38                         return socket;
  39         }
  40
  41         return 0;
  42 }
  43
  44 int socket (int family, int type, int protocol)
  45 {
  46         socket_t *sock;
  47
  48         /* alloc and init context */
  49         sock = (socket_t *) kmalloc (sizeof (socket_t));
  50
  51         sock->fd = fd_count ++;
  52         sock->family = family;
  53         sock->type = type;
  54         sock->protocol = protocol;
  55
  56         switch (sock->protocol) {
  57                 case IPPROTO_TCP:
  58                         switch (sock->family) {
  59                                 case AF_UNSPEC:
  60                                         return -1;
  61                                 case AF_UNIX:
  62
  63                                         return -1;
  64                                 case AF_INET:
  65                                         sock->fd = net_proto_tcp_socket ();
  66                                         break;
  67                                 case AF_INET6:
  68                                         sock->fd = net_proto_tcp6_socket ();
  69                                         break;
  70                                 case AF_RS232:
  71                                         sock->fd = ips_socket ();
  72                                         break;
  73                         }
  74                         break;
  75                 case IPPROTO_UDP:
  76                         switch (sock->family) {
  77                                 case AF_UNSPEC:
  78                                         return -1;
  79                                 case AF_UNIX:
  80
  81                                         return -1;
  82                                 case AF_INET:
  83                                         sock->fd = net_proto_udp_socket ();
  84                                         break;
  85                                 case AF_INET6:
  86                                         sock->fd = net_proto_udp6_socket ();
  87                                         break;
  88                                 case AF_RS232:
  89                                         return -1;
  90                         }
  91                         break;
  92         }
  93
  94         /* add into list */
  95         sock->next = &socket_list;
  96         sock->prev = socket_list.prev;
  97         sock->prev->next = sock;
  98         sock->next->prev = sock;
  99
 100         fd_t *fd = (fd_t *) kmalloc (sizeof (fd_t));
 101
 102         fd->flags = FD_SOCK;
 103         fd->id = sock->fd;
 104
 105         proc_t *proc = proc_find (_curr_task);
 106
 107         if (!proc)
 108                 return;
 109
 110         if (proc->task != _curr_task)
 111                 return;
 112
 113         fd->proc = proc;
 114
 115         fd->next = &fd_list;
 116         fd->prev = fd_list.prev;
 117         fd->prev->next = fd;
 118         fd->next->prev = fd;
 119
 120         return sock->fd;
 121 }
 122
 123 hostent *gethostbyname (char *hostname)
 124 {
 125         unsigned i = 0;
 126         unsigned g = 0;
 127         unsigned l = strlen (hostname);
 128
 129         /* TODO: make better checking, that it is ip addresss */
 130         while (i < l) {
 131                 if (hostname[i] == '.')
 132                         g ++;
 133
 134                 i ++;
 135         }
 136
 137         unsigned target = 0;
 138
 139         /* it is dns address */
 140         if (g != 3) {
 141                 target = dns_cache_get (hostname);
 142
 143                 if (!target)
 144                         target = dns_send_request (hostname);
 145         } else
 146                 target = net_proto_ip_convert (hostname);
 147
 148         if (!target)
 149                 return 0;
 150
 151         hostent *host = (hostent *) kmalloc (sizeof (hostent));
 152
 153         if (!host)
 154                 return 0;
 155
 156         memset (host, 0, sizeof (hostent));
 157
 158         /* 4bytes - unsigned - for ipv4 */
 159         host->h_length = 4;
 160
 161         host->h_addr = (char *) kmalloc (sizeof (char) * host->h_length);
 162
 163         if (!host->h_addr) {
 164                 kfree (host);
 165                 return 0;
 166         }
 167
 168         memcpy (host->h_addr, &target, host->h_length);
 169
 170         return host;
 171 }
 172
 173 int connect (int fd, sockaddr *addr, socklen_t len)
 174 {
 175         DPRINT ("connect () -> socket: %d\n", fd);
 176         socket_t *sock = socket_getbyfd (fd);
 177
 178         if (!sock)
 179                 return -1;
 180
 181         switch (sock->protocol) {
 182                 case IPPROTO_TCP:
 183                         switch (sock->family) {
 184                                 case AF_UNSPEC:
 185
 186                                         return -1;
 187                                 case AF_UNIX:
 188
 189                                         return -1;
 190                                 case AF_INET:
 191                                         return net_proto_tcp_connect (fd, (sockaddr_in *) addr);
 192                                 case AF_INET6:
 193                                         return net_proto_tcp6_connect (fd, (sockaddr_in6 *) addr);
 194                                 case AF_RS232:
 195                                         return ips_connect (fd, addr);
 196                         }
 197                         break;
 198                 case IPPROTO_UDP:
 199                         switch (sock->family) {
 200                                 case AF_UNSPEC:
 201
 202                                         return -1;
 203                                 case AF_UNIX:
 204
 205                                         return -1;
 206                                 case AF_INET:
 207                                         return net_proto_udp_connect (fd, addr);
 208                                 case AF_INET6:
 209                                         return net_proto_udp6_connect (fd, (sockaddr_in6 *) addr);
 210                                 case AF_RS232:
 211
 212                                         return -1;
 213                         }
 214                         break;
 215         }
 216
 217         return 1;
 218 }
 219
 220 int send (int fd, char *msg, size_t size, int flags)
 221 {
 222         socket_t *sock = socket_getbyfd (fd);
 223
 224         if (!sock)
 225                 return -1;
 226
 227         DPRINT ("send (%d) -> %s\n", fd, msg);
 228
 229         switch (sock->protocol) {
 230                 case IPPROTO_TCP:
 231                         switch (sock->family) {
 232                                 case AF_UNSPEC:
 233
 234                                         return -1;
 235                                 case AF_UNIX:
 236
 237                                         return -1;
 238                                 case AF_INET:
 239                                         return net_proto_tcp_send (fd, msg, size);
 240                                 case AF_INET6:
 241                                         return net_proto_tcp6_send (fd, msg, size);
 242                                 case AF_RS232:
 243                                         return ips_send (fd, msg, size);
 244                         }
 245                         break;
 246                 case IPPROTO_UDP:
 247                         switch (sock->family) {
 248                                 case AF_UNSPEC:
 249
 250                                         return -1;
 251                                 case AF_UNIX:
 252
 253                                         return -1;
 254                                 case AF_INET:
 255                                         return net_proto_udp_send (fd, msg, size);
 256                                 case AF_INET6:
 257                                         return net_proto_udp6_send (fd, msg, size);
 258                                 case AF_RS232:
 259
 260                                         return -1;
 261                         }
 262                         break;
 263         }
 264
 265         return 1;
 266 }
 267
 268 int sendto (int fd, const void *msg, size_t len, int flags, sockaddr *to, socklen_t tolen)
 269 {
 270         socket_t *sock = socket_getbyfd (fd);
 271
 272         if (!sock)
 273                 return -1;
 274
 275         DPRINT ("sendto (%d) -> %s\n", fd, msg);
 276
 277         switch (sock->protocol) {
 278                 case IPPROTO_TCP:
 279                         switch (sock->family) {
 280                                 case AF_UNSPEC:
 281
 282                                         return -1;
 283                                 case AF_UNIX:
 284
 285                                         return -1;
 286                                 case AF_INET:
 287                                         return -1; // net_proto_tcp_sendto (fd, msg, len, to);
 288                                 case AF_INET6:
 289                                         return -1; // net_proto_tcp6_sendto (fd, msg, len, to);
 290                                 case AF_RS232:
 291
 292                                         return -1;
 293                         }
 294                         break;
 295                 case IPPROTO_UDP:
 296                         switch (sock->family) {
 297                                 case AF_UNSPEC:
 298
 299                                         return -1;
 300                                 case AF_UNIX:
 301
 302                                         return -1;
 303                                 case AF_INET:
 304                                         return net_proto_udp_sendto (fd, msg, len, (sockaddr_in *) to);
 305                                 case AF_INET6:
 306                                         return net_proto_udp6_sendto (fd, msg, len, (sockaddr_in6 *) to);
 307                                 case AF_RS232:
 308
 309                                         return -1;
 310                         }
 311                         break;
 312         }
 313
 314         return 1;
 315 }
 316
 317 int recv (int fd, char *msg, size_t size, int flags)
 318 {
 319         socket_t *sock = socket_getbyfd (fd);
 320
 321         if (!sock)
 322                 return -1;
 323
 324         DPRINT ("recv (%d)\n", fd);
 325
 326         switch (sock->protocol) {
 327                 case IPPROTO_TCP:
 328                         switch (sock->family) {
 329                                 case AF_UNSPEC:
 330
 331                                         return -1;
 332                                 case AF_UNIX:
 333
 334                                         return -1;
 335                                 case AF_INET:
 336                                         return net_proto_tcp_recv (fd, msg, size);
 337                                 case AF_INET6:
 338                                         return net_proto_tcp6_recv (fd, msg, size);
 339                                 case AF_RS232:
 340                                         return ips_recv (fd, msg, size);
 341                         }
 342                         break;
 343                 case IPPROTO_UDP:
 344                         switch (sock->family) {
 345                                 case AF_UNSPEC:
 346
 347                                         return -1;
 348                                 case AF_UNIX:
 349
 350                                         return -1;
 351                                 case AF_INET:
 352                                         return net_proto_udp_recv (fd, msg, size);
 353                                 case AF_INET6:
 354                                         return net_proto_udp6_recv (fd, msg, size);
 355                                 case AF_RS232:
 356
 357                                         return -1;
 358                         }
 359                         break;
 360         }
 361
 362         return 1;
 363 }
 364
 365 int recvfrom (int fd, char *msg, size_t size, int flags, sockaddr *from, socklen_t fromlen)
 366 {
 367         socket_t *sock = socket_getbyfd (fd);
 368
 369         if (!sock)
 370                 return -1;
 371
 372         DPRINT ("recvfrom (%d)\n", fd);
 373
 374         switch (sock->protocol) {
 375                 case IPPROTO_TCP:
 376                         switch (sock->family) {
 377                                 case AF_UNSPEC:
 378
 379                                         return -1;
 380                                 case AF_UNIX:
 381
 382                                         return -1;
 383                                 case AF_INET:
 384                                         return -1; //net_proto_tcp_recvfrom (fd, msg, size, from);
 385                                 case AF_INET6:
 386                                         return -1; //net_proto_tcp6_recvfrom (fd, msg, size, from);
 387                                 case AF_RS232:
 388
 389                                         return -1;
 390                         }
 391                         break;
 392                 case IPPROTO_UDP:
 393                         switch (sock->family) {
 394                                 case AF_UNSPEC:
 395
 396                                         return -1;
 397                                 case AF_UNIX:
 398
 399                                         return -1;
 400                                 case AF_INET:
 401                                         return net_proto_udp_recvfrom (fd, msg, size, (sockaddr_in *) from);
 402                                 case AF_INET6:
 403                                         return net_proto_udp6_recvfrom (fd, msg, size, (sockaddr_in6 *) from);
 404                                 case AF_RS232:
 405
 406                                         return -1;
 407                         }
 408                         break;
 409         }
 410
 411         return 1;
 412 }
 413
 414 int bind (int fd, sockaddr *addr, socklen_t len)
 415 {
 416         socket_t *sock = socket_getbyfd (fd);
 417
 418         if (!sock)
 419                 return -1;
 420
 421         DPRINT ("bind (%d)\n", fd);
 422
 423         switch (sock->protocol) {
 424                 case IPPROTO_TCP:
 425                         switch (sock->family) {
 426                                 case AF_UNSPEC:
 427
 428                                         return -1;
 429                                 case AF_UNIX:
 430
 431                                         return -1;
 432                                 case AF_INET:
 433                                         return net_proto_tcp_bind (fd, (sockaddr_in *) addr, len);
 434                                 case AF_INET6:
 435                                         return net_proto_tcp6_bind (fd, (sockaddr_in6 *) addr, len);
 436                                 case AF_RS232:
 437                                         return ips_bind (fd, addr);
 438                         }
 439                         break;
 440                 case IPPROTO_UDP:
 441                         switch (sock->family) {
 442                                 case AF_UNSPEC:
 443
 444                                         return -1;
 445                                 case AF_UNIX:
 446
 447                                         return -1;
 448                                 case AF_INET:
 449                                         return net_proto_udp_bind (fd, (sockaddr_in *) addr, len);
 450                                 case AF_INET6:
 451                                         return net_proto_udp6_bind (fd, (sockaddr_in6 *) addr, len);
 452                                 case AF_RS232:
 453                                         return -1;
 454                         }
 455                         break;
 456         }
 457
 458         return 1;
 459 }
 460
 461 int listen (int fd, int backlog)
 462 {
 463         socket_t *sock = socket_getbyfd (fd);
 464
 465         if (!sock)
 466                 return -1;
 467
 468         DPRINT ("listen (%d)\n", fd);
 469
 470         switch (sock->family) {
 471                 case AF_UNSPEC:
 472
 473                         return -1;
 474                 case AF_UNIX:
 475
 476                         return -1;
 477                 case AF_INET:
 478                         return net_proto_tcp_listen (fd, backlog);
 479                 case AF_INET6:
 480                         return net_proto_tcp6_listen (fd, backlog);
 481                 case AF_RS232:
 482                         return ips_listen (fd, backlog);
 483         }
 484
 485         return 1;
 486 }
 487
 488 int accept (int fd, sockaddr *addr, socklen_t *addrlen)
 489 {
 490         socket_t *servsock = socket_getbyfd (fd);
 491
 492         if (!servsock)
 493                 return -1;
 494
 495         DPRINT ("accept (%d)\n", fd);
 496
 497         int client = 0;
 498
 499         switch (servsock->family) {
 500                 case AF_UNSPEC:
 501
 502                         return -1;
 503                 case AF_UNIX:
 504
 505                         return -1;
 506                 case AF_INET:
 507                         client = net_proto_tcp_accept (fd, (sockaddr_in *) addr, addrlen);
 508                         break;
 509                 case AF_INET6:
 510                         client = net_proto_tcp6_accept (fd, (sockaddr_in6 *) addr, addrlen);
 511                         break;
 512                 case AF_RS232:
 513                         client = ips_accept (fd, addr, addrlen);
 514                         break;
 515         }
 516
 517         if (client <= 0)
 518                 return client;
 519
 520         socket_t *sock;
 521
 522         /* alloc and init context */
 523         sock = (socket_t *) kmalloc (sizeof (socket_t));
 524
 525         fd_count ++;
 526         sock->fd = client;
 527         sock->family = servsock->family;
 528         sock->type = servsock->type;
 529         sock->protocol = servsock->protocol;
 530
 531         /* add into list */
 532         sock->next = &socket_list;
 533         sock->prev = socket_list.prev;
 534         sock->prev->next = sock;
 535         sock->next->prev = sock;
 536
 537         fd_t *fd_client = (fd_t *) kmalloc (sizeof (fd_t));
 538
 539         fd_client->flags = FD_SOCK;
 540         fd_client->id = sock->fd;
 541
 542         fd_client->next = &fd_list;
 543         fd_client->prev = fd_list.prev;
 544         fd_client->prev->next = fd_client;
 545         fd_client->next->prev = fd_client;
 546
 547         return client;
 548 }
 549
 550 int sclose (int fd)
 551 {
 552         socket_t *sock = socket_getbyfd (fd);
 553
 554         if (!sock)
 555                 return -1;
 556
 557         DPRINT ("close (%d)\n", fd);
 558
 559         switch (sock->protocol) {
 560                 case IPPROTO_TCP:
 561                         switch (sock->family) {
 562                                 case AF_UNSPEC:
 563
 564                                         return -1;
 565                                 case AF_UNIX:
 566
 567                                         return -1;
 568                                 case AF_INET:
 569                                         return net_proto_tcp_close (fd);
 570                                 case AF_INET6:
 571                                         return net_proto_tcp6_close (fd);
 572                                 case AF_RS232:
 573                                         return ips_close (fd);
 574                         }
 575                         break;
 576                 case IPPROTO_UDP:
 577                         switch (sock->family) {
 578                                 case AF_UNSPEC:
 579
 580                                         return -1;
 581                                 case AF_UNIX:
 582
 583                                         return -1;
 584                                 case AF_INET:
 585                                         return net_proto_udp_close (fd);
 586                                 case AF_INET6:
 587                                         return net_proto_udp6_close (fd);
 588                                 case AF_RS232:
 589
 590                                         return -1;
 591                         }
 592                         break;
 593         }
 594
 595         return 1;
 596 }
 597
 598 int sfcntl (int fd, int cmd, long arg)
 599 {
 600         socket_t *sock = socket_getbyfd (fd);
 601
 602         if (!sock)
 603                 return -1;
 604
 605         DPRINT ("fcntl (%d)\n", fd);
 606
 607         switch (sock->protocol) {
 608                 case IPPROTO_TCP:
 609                         switch (sock->family) {
 610                                 case AF_UNSPEC:
 611
 612                                         return -1;
 613                                 case AF_UNIX:
 614
 615                                         return -1;
 616                                 case AF_INET:
 617                                         return net_proto_tcp_fcntl (fd, cmd, arg);
 618                                 case AF_INET6:
 619                                         return net_proto_tcp6_fcntl (fd, cmd, arg);
 620                                 case AF_RS232:
 621                                         return ips_fcntl (fd);
 622                         }
 623                         break;
 624                 case IPPROTO_UDP:
 625                         switch (sock->family) {
 626                                 case AF_UNSPEC:
 627
 628                                         return -1;
 629                                 case AF_UNIX:
 630
 631                                         return -1;
 632                                 case AF_INET:
 633                                         return net_proto_udp_fcntl (fd, cmd, arg);
 634                                 case AF_INET6:
 635                                         return net_proto_udp6_fcntl (fd, cmd, arg);
 636                                 case AF_RS232:
 637
 638                                         return -1;
 639                         }
 640                         break;
 641         }
 642
 643 }
 644
 645 unsigned int init_socket ()
 646 {
 647         socket_list.next = &socket_list;
 648         socket_list.prev = &socket_list;
 649
 650         fd_count = 0;
 651
 652         return 1;
 653 }
 654