kernel/core/net/unix.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *
   5  *  This program is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19
  20 #include <system.h>
  21 #include <string.h>
  22 #include <fd.h>
  23 #include <net/eth.h>
  24 #include <net/net.h>
  25 #include <net/if.h>
  26 #include <net/packet.h>
  27 #include <net/socket.h>
  28 #include <net/unix.h>
  29 #include <errno.h>
  30
  31 proto_unix_conn_t proto_unix_conn_list;
  32 proto_unix_backlog_t proto_unix_backlog_list;
  33
  34 /* prototypes */
  35 int net_proto_unix_read_cache (proto_unix_conn_t *conn, char *data, unsigned len);
  36 int net_proto_unix_write (proto_unix_conn_t *conn, char *data, unsigned len);
  37 proto_unix_conn_t *net_proto_unix_conn_find (int fd);
  38 proto_unix_conn_t *net_proto_unix_conn_findbypath (char *path);
  39 int net_proto_unix_conn_set (proto_unix_conn_t *conn, char *path, unsigned char bind);
  40 unsigned net_proto_unix_conn_del (proto_unix_conn_t *conn);
  41 int net_proto_unix_conn_add ();
  42 int net_proto_unix_backlog_add (proto_unix_conn_t *conn, proto_unix_conn_t *session);
  43
  44 /** Unix protocol
  45  *  User-friendly socket functions
  46  */
  47 int net_proto_unix_socket (fd_t *fd)
  48 {
  49         return net_proto_unix_conn_add (fd);
  50 }
  51
  52 extern unsigned long timer_ticks;
  53 int net_proto_unix_connect (int fd, sockaddr_un *addr)
  54 {
  55         int ret = -1;
  56
  57         proto_unix_conn_t *session = net_proto_unix_conn_findbypath (addr->sun_path);
  58
  59         if (!session)
  60                 return -1;
  61
  62         proto_unix_conn_t *conn = net_proto_unix_conn_find (fd);
  63
  64         if (!conn)
  65                 return -1;
  66
  67         ret = net_proto_unix_conn_set (conn, addr->sun_path, 0);
  68
  69         if (!net_proto_unix_backlog_add (session, conn))
  70                 return -1;
  71
  72         //conn->session = session;
  73
  74         unsigned long stime = timer_ticks;
  75
  76         /* blocking mode */
  77         if (!(conn->flags & O_NONBLOCK)) {
  78                 if (!ret)
  79                         return -1;
  80
  81                 for (;;) {
  82                         schedule ();
  83
  84                         /* timeout for 3s */
  85                         if ((stime+3000) < timer_ticks)
  86                                 return -1;
  87
  88                         if (conn->state == PROTO_UNIX_CONN_STATE_ESTABILISHED) {
  89                                 ret = 0;
  90                                 break;
  91                         }
  92                 }
  93         } else
  94         /* non-blocking mode */
  95                 return -1;
  96
  97         return ret;
  98 }
  99
 100 int net_proto_unix_send (int fd, char *msg, unsigned size)
 101 {
 102         proto_unix_conn_t *conn = net_proto_unix_conn_find (fd);
 103
 104         if (!conn)
 105                 return -1;
 106
 107         int ret = net_proto_unix_write (conn, msg, size);
 108
 109         if (ret) {
 110                 /* blocking mode */
 111                 if (!(conn->flags & O_NONBLOCK)) {
 112
 113                 } else {
 114                 /* non-blocking mode */
 115                 /* TODO: ? */
 116
 117                 }
 118         }
 119
 120         return size;
 121 }
 122
 123 extern unsigned long timer_ticks;
 124 int net_proto_unix_recv (int fd, char *msg, unsigned size)
 125 {
 126         proto_unix_conn_t *conn = net_proto_unix_conn_find (fd);
 127
 128         if (!conn)
 129                 return -3;
 130
 131         if (!msg)
 132                 return -4;
 133
 134         int ret = 0;
 135
 136         /* blocking mode */
 137         if (!(conn->flags & O_NONBLOCK)) {
 138                 unsigned long stime = timer_ticks;
 139
 140                 while (!conn->len) {
 141                         if ((stime+10000) < timer_ticks)
 142                                 return 0;
 143
 144                         schedule ();
 145                 }
 146         } else {
 147                 if (!conn->len)
 148                         return 0;
 149         }
 150
 151         if (!conn->data)
 152                 return -5;
 153
 154         if (conn->len >= size)
 155                 return -2;
 156
 157         ret = conn->len;
 158
 159         if (conn->len > 0)
 160                 memcpy (msg, conn->data, conn->len);
 161
 162         conn->len = 0;
 163
 164         kfree (conn->data);
 165
 166         return ret;
 167 }
 168
 169
 170 int net_proto_unix_close (int fd)
 171 {
 172         proto_unix_conn_t *conn = net_proto_unix_conn_find (fd);
 173
 174         if (!conn)
 175                 return -1;
 176
 177         int ret = net_proto_unix_conn_del (conn);
 178
 179         return ret;
 180 }
 181
 182 int net_proto_unix_fcntl (int fd, int cmd, long arg)
 183 {
 184         proto_unix_conn_t *conn = net_proto_unix_conn_find (fd);
 185
 186         if (!conn)
 187                 return -1;
 188
 189         switch (cmd) {
 190                 case F_GETFL:
 191                         return conn->flags;
 192                 case F_SETFL:
 193                         conn->flags = arg;
 194                         return 0;
 195         }
 196
 197         return -1;
 198 }
 199
 200 int net_proto_unix_bind (int fd, sockaddr_un *addr, socklen_t len)
 201 {
 202         proto_unix_conn_t *conn = net_proto_unix_conn_find (fd);
 203
 204         if (!conn)
 205                 return -1;
 206
 207         int ret = net_proto_unix_conn_set (conn, addr->sun_path, 1);
 208
 209         if (ret)
 210                 return 0;
 211
 212         return -1;
 213 }
 214
 215 int net_proto_unix_listen (int fd, int backlog)
 216 {
 217         /* TODO */
 218
 219         return 0;
 220 }
 221
 222 int net_proto_unix_accept (int fd, sockaddr_un *addr, socklen_t *addrlen)
 223 {
 224         proto_unix_conn_t *conn = net_proto_unix_conn_find (fd);
 225
 226         if (!conn)
 227                 return -1;
 228
 229         unsigned i = 0;
 230
 231         proto_unix_backlog_t *backlog = 0;
 232
 233         /* blocking mode */
 234         if (!(conn->flags & O_NONBLOCK)) {
 235                 while (!i) {
 236                         for (backlog = proto_unix_backlog_list.next; backlog != &proto_unix_backlog_list; backlog = backlog->next) {
 237                                 if (backlog->conn == conn) {
 238                                         i = 1;
 239                                         break;
 240                                 }
 241                         }
 242
 243                         schedule ();
 244                 }
 245         } else {
 246         /* non-blocking mode */
 247                 for (backlog = proto_unix_backlog_list.next; backlog != &proto_unix_backlog_list; backlog = backlog->next) {
 248                         if (backlog->conn == conn) {
 249                                 i = 1;
 250                                 break;
 251                         }
 252                 }
 253         }
 254
 255         if (!i)
 256                 return -1;
 257
 258         fd_t *fd_new = fd_create (FD_SOCK);
 259
 260         if (!fd_new)
 261                 return -1;
 262
 263         net_proto_unix_conn_add (fd_new);
 264
 265         proto_unix_conn_t *conn_new = net_proto_unix_conn_find (fd_new->id);
 266
 267         if (!conn_new)
 268                 return -1;
 269
 270         backlog->session->session = conn_new;
 271         backlog->session->state = PROTO_UNIX_CONN_STATE_ESTABILISHED;
 272
 273         net_proto_unix_conn_set (conn_new, conn->path, 0);
 274
 275         conn_new->session = (void *) backlog->session;
 276
 277         /* remove from queue accepted connection */
 278         backlog->next->prev = backlog->prev;
 279         backlog->prev->next = backlog->next;
 280
 281         kfree (backlog);
 282
 283         return fd_new->id;
 284 }
 285
 286 /** UNIX protocol
 287  *  hardcore code :P
 288  */
 289
 290 int net_proto_unix_write (proto_unix_conn_t *conn, char *data, unsigned len)
 291 {
 292         if (!data || !conn || !len)
 293                 return 0;
 294
 295         conn = (proto_unix_conn_t *) conn->session;
 296
 297         if (!conn)
 298                 return 0;
 299
 300         if (!conn->len)
 301                 conn->data = (char *) kmalloc (sizeof (char) * (len + 1));
 302         else
 303                 conn->data = (char *) krealloc (conn->data, (sizeof (char) * (conn->len+len)));
 304
 305         if (!conn->data)
 306                 return -1;
 307
 308         memcpy (conn->data+conn->len, data, len);
 309
 310         conn->len += len;
 311
 312         return conn->len;
 313 }
 314
 315
 316 /* Create new UNIX connection */
 317 int net_proto_unix_conn_add (fd_t *fd)
 318 {
 319         proto_unix_conn_t *conn;
 320
 321         /* alloc and init context */
 322         conn = (proto_unix_conn_t *) kmalloc (sizeof (proto_unix_conn_t));
 323
 324         if (!conn) {
 325                 errno_set (ENOMEM);
 326                 return -1;
 327         }
 328
 329         memset (conn, 0, sizeof (proto_unix_conn_t));
 330
 331         conn->flags = 0;
 332         conn->path = 0;
 333         conn->session = 0;
 334
 335         conn->fd = fd->id;
 336
 337         /* add into list */
 338         conn->next = &proto_unix_conn_list;
 339         conn->prev = proto_unix_conn_list.prev;
 340         conn->prev->next = conn;
 341         conn->next->prev = conn;
 342
 343         return 0;
 344 }
 345
 346 /* Setup new connection */
 347 int net_proto_unix_conn_set (proto_unix_conn_t *conn, char *path, unsigned char bind)
 348 {
 349         if (!conn)
 350                 return 0;
 351
 352         unsigned l = strlen (path);
 353
 354         if (!l)
 355                 return 0;
 356
 357         conn->path = (char *) kmalloc (sizeof (char) * (l + 1));
 358
 359         if (!conn->path)
 360                 return 0;
 361
 362         memcpy (conn->path, path, l);
 363         conn->path[l] = '\0';
 364
 365         conn->len = 0;
 366         conn->data = 0;
 367         conn->bind = bind;
 368
 369         return 1;
 370 }
 371
 372 /* Delete existing connection from list */
 373 unsigned net_proto_unix_conn_del (proto_unix_conn_t *conn)
 374 {
 375         if (!conn)
 376                 return 0;
 377
 378         if (conn->len)
 379                 kfree (conn->data);
 380
 381         if (conn->path)
 382                 kfree (conn->path);
 383
 384         conn->len = 0;
 385
 386         conn->next->prev = conn->prev;
 387         conn->prev->next = conn->next;
 388
 389         kfree (conn);
 390
 391         return 1;
 392 }
 393
 394 proto_unix_conn_t *net_proto_unix_conn_find (int fd)
 395 {
 396         proto_unix_conn_t *conn = NULL;
 397         for (conn = proto_unix_conn_list.next; conn != &proto_unix_conn_list; conn = conn->next) {
 398                 if (conn->fd == fd)
 399                         return conn;
 400         }
 401
 402         return 0;
 403 }
 404
 405 proto_unix_conn_t *net_proto_unix_conn_findbypath (char *path)
 406 {
 407         proto_unix_conn_t *conn = NULL;
 408         for (conn = proto_unix_conn_list.next; conn != &proto_unix_conn_list; conn = conn->next) {
 409                 if (!conn->path)
 410                         continue;
 411
 412                 if (!strcmp (conn->path, path) && conn->bind)
 413                         return conn;
 414         }
 415
 416         return 0;
 417 }
 418
 419 /* Create new UNIX backlog stamp */
 420 int net_proto_unix_backlog_add (proto_unix_conn_t *conn, proto_unix_conn_t *session)
 421 {
 422         if (!conn)
 423                 return 0;
 424
 425         proto_unix_backlog_t *backlog;
 426
 427         /* alloc and init context */
 428         backlog = (proto_unix_backlog_t *) kmalloc (sizeof (proto_unix_backlog_t));
 429
 430         if (!backlog)
 431                 return 0;
 432
 433         backlog->conn = conn;
 434         backlog->session = session;
 435
 436         /* add into list */
 437         backlog->next = &proto_unix_backlog_list;
 438         backlog->prev = proto_unix_backlog_list.prev;
 439         backlog->prev->next = backlog;
 440         backlog->next->prev = backlog;
 441
 442         return 1;
 443 }
 444
 445 /* init of unix protocol */
 446 unsigned init_net_proto_unix ()
 447 {
 448         proto_unix_conn_list.next = &proto_unix_conn_list;
 449         proto_unix_conn_list.prev = &proto_unix_conn_list;
 450
 451         proto_unix_backlog_list.next = &proto_unix_backlog_list;
 452         proto_unix_backlog_list.prev = &proto_unix_backlog_list;
 453
 454         return 1;
 455 }