kernel/drivers/fs/znfs.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 <config.h>
  21 #include <build.h>
  22
  23 #ifdef ARCH_i386
  24
  25 #include <system.h>
  26 #include <string.h>
  27 #include <dev.h>
  28 #include <fs.h>
  29 #include <partition.h>
  30 #include <net/socket.h>
  31 #include <cache.h>
  32 #include <vfs.h>
  33
  34 #define PROTO_MKDIR     0x1
  35 #define PROTO_RMDIR     0x2
  36 #define PROTO_CREAT     0x3
  37 #define PROTO_RM        0x4
  38 #define PROTO_CHDIR     0x5
  39 #define PROTO_READ      0x6
  40
  41 partition_t *znfs_part;
  42 int sock;
  43 unsigned char znfs_dir_id;
  44
  45 /* clear and pre-set dir[] structure */
  46 void znfs_dir_flush (unsigned n)
  47 {
  48         strcpy (dir[0].name, ".");
  49         strcpy (dir[1].name, "..");
  50
  51         znfs_dir_id = 2;
  52
  53         unsigned i = znfs_dir_id;
  54
  55         for (; i < 223; i ++)
  56                 memset (dir[i].name, 0, 10);
  57 }
  58
  59 int znfs_send (int fd, unsigned char cmd, char *data, unsigned len)
  60 {
  61         char *s = kmalloc (sizeof (char) * len + 2);
  62
  63         if (!s)
  64                 return 0;
  65
  66         s[0] = cmd;
  67         memcpy (s+1, data, len);
  68
  69         int ret = send (fd, s, len+1, 0);
  70
  71         kfree (s);
  72
  73         return ret;
  74 }
  75
  76 int znfs_recv (int fd, char *data, unsigned len)
  77 {
  78         return recv (fd, data, len, 0);
  79 }
  80
  81 /* function for read file content */
  82 unsigned znfs_read (partition_t *p, unsigned char *name, vfs_content_t *content)
  83 {
  84         unsigned char l = strlen (name);
  85
  86         if (l > 10)
  87                 l = 10;
  88
  89         char data[12];
  90
  91         data[0] = l;
  92         memcpy (data+1, name, l);
  93
  94         // Set socket to blocking mode
  95         int oldFlag = fcntl (sock, F_GETFL, 0);
  96         oldFlag &= ~O_NONBLOCK;
  97
  98         if (fcntl (sock, F_SETFL, oldFlag) == -1) {
  99                 printf ("Cant set socket to nonblocking mode\n");
 100                 return 0;
 101         }
 102
 103         znfs_send (sock, PROTO_READ, data, l+1);
 104
 105         int r = 0;
 106
 107         cache_t *cache = cache_create (0, 0, 0);
 108
 109         if (!cache)
 110                 return 0;
 111
 112         char block[512];
 113
 114         while (1) {
 115                 r = znfs_recv (sock, block, 512);
 116
 117                 cache_add (block, r);
 118
 119                 if (r != 512)
 120                         break;
 121         }
 122
 123         // Set socket to non-blocking mode
 124         oldFlag = fcntl (sock, F_GETFL, 0);
 125         if (fcntl (sock, F_SETFL, oldFlag | O_NONBLOCK) == -1) {
 126                 printf ("Cant set socket to nonblocking mode\n");
 127                 return 0;
 128         }
 129
 130         content->ptr = (char *) &cache->data;
 131         content->len = cache->limit;
 132
 133         return 1;
 134 }
 135
 136 /* function for create clear directory */
 137 unsigned znfs_create_directory (partition_t *p, unsigned char *name)
 138 {
 139         unsigned char l = strlen (name);
 140
 141         if (l > 10)
 142                 l = 10;
 143
 144         char data[12];
 145
 146         data[0] = l;
 147         memcpy (data+1, name, l);
 148
 149         znfs_send (sock, PROTO_MKDIR, data, l+1);
 150
 151
 152         memcpy (dir[znfs_dir_id].name, name, l);
 153         dir[znfs_dir_id].name[l] = '\0';
 154
 155         dir[znfs_dir_id].dir = 1;
 156
 157         znfs_dir_id ++;
 158
 159         return 1;
 160 }
 161
 162 /* function for create blank file */
 163 unsigned znfs_create_file (partition_t *p, unsigned char *name)
 164 {
 165         unsigned char l = strlen (name);
 166
 167         if (l > 10)
 168                 l = 10;
 169
 170         char data[12];
 171
 172         data[0] = l;
 173         memcpy (data+1, name, l);
 174
 175         znfs_send (sock, PROTO_CREAT, data, l+1);
 176
 177         memcpy (dir[znfs_dir_id].name, name, l);
 178         dir[znfs_dir_id].name[l] = '\0';
 179
 180         dir[znfs_dir_id].dir = 0;
 181
 182         znfs_dir_id ++;
 183
 184         return 1;
 185 }
 186
 187 /* go to next directory placed in current directory */
 188 void znfs_cd (partition_t *p, unsigned char *name)
 189 {
 190         unsigned short l = strlen (name);
 191
 192         if (l > 1023)
 193                 l = 1023;
 194
 195         char data[1024];
 196
 197         data[0] = l;
 198         memcpy (data+1, name, l);
 199
 200         znfs_send (sock, PROTO_CHDIR, data, l+1);
 201
 202         znfs_dir_flush (1);
 203
 204         // Set socket to blocking mode
 205         int oldFlag = fcntl (sock, F_GETFL, 0);
 206         oldFlag &= ~O_NONBLOCK;
 207
 208         if (fcntl (sock, F_SETFL, oldFlag) == -1) {
 209                 printf ("Cant set socket to nonblocking mode\n");
 210         }
 211
 212         int r = znfs_recv (sock, data, 1024);
 213
 214         // Set socket to non-blocking mode
 215         oldFlag = fcntl (sock, F_GETFL, 0);
 216         if (fcntl (sock, F_SETFL, oldFlag | O_NONBLOCK) == -1) {
 217                 printf ("Cant set socket to nonblocking mode\n");
 218         }
 219
 220         if (r < 1) {
 221                 kprintf ("ZNFS -> error in receiving directory list\n");
 222                 return;
 223         }
 224
 225         unsigned char n = r/13;
 226
 227         struct dent {
 228                 unsigned char type;
 229                 char name[12];
 230         } __attribute__ ((__packed__));
 231
 232         struct dent *d = (struct dent *) data;
 233
 234         for (l = 0; l < n; l ++) {
 235                 memcpy (dir[l].name, d[l].name, 12);
 236
 237                 if (d[l].type == 0x4)
 238                         dir[l].dir = 1;
 239                 else
 240                         dir[l].dir = 0;
 241         }
 242 }
 243
 244 /* go to root '/' directory on partition */
 245 void znfs_cd_root (partition_t *p)
 246 {
 247         char data[1024];
 248
 249         data[0] = 1;
 250         data[1] = '/';
 251
 252         znfs_send (sock, PROTO_CHDIR, data, 2);
 253
 254         znfs_dir_flush (1);
 255
 256         // Set socket to blocking mode
 257         int oldFlag = fcntl (sock, F_GETFL, 0);
 258         oldFlag &= ~O_NONBLOCK;
 259
 260         if (fcntl (sock, F_SETFL, oldFlag) == -1) {
 261                 printf ("Cant set socket to nonblocking mode\n");
 262         }
 263
 264         int r = znfs_recv (sock, data, 1024);
 265
 266         // Set socket to non-blocking mode
 267         oldFlag = fcntl (sock, F_GETFL, 0);
 268         if (fcntl (sock, F_SETFL, oldFlag | O_NONBLOCK) == -1) {
 269                 printf ("Cant set socket to nonblocking mode\n");
 270         }
 271
 272         if (r < 1) {
 273                 kprintf ("ZNFS -> error in receiving directory list\n");
 274                 return;
 275         }
 276
 277         unsigned char n = r/13;
 278         unsigned char l;
 279
 280         struct dent {
 281                 unsigned char type;
 282                 char name[12];
 283         } __attribute__ ((__packed__));
 284
 285         struct dent *d = (struct dent *) data;
 286
 287         for (l = 0; l < n; l ++) {
 288                 memcpy (dir[l].name, d[l].name, 12);
 289
 290                 if (d[l].type == 0x4)
 291                         dir[l].dir = 1;
 292                 else
 293                         dir[l].dir = 0;
 294         }
 295 }
 296
 297 /* zexos filesystem initialization function */
 298 unsigned znfs_init (partition_t *p, char *addr)
 299 {
 300 #ifdef CONFIG_DRV_ZNFS
 301         znfs_part =  p;
 302
 303         int port = 5333;
 304         hostent *host;
 305         sockaddr_in serverSock;
 306
 307         // Let's get info about remote computer
 308         if ((host = gethostbyname ((char *) addr)) == NULL) {
 309                 printf ("Wrong address -> %s:%d\n", addr, port);
 310                 return 0;
 311         }
 312
 313         // Create socket
 314         if ((sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
 315                 printf ("Cant create socket\n");
 316                 return 0;
 317         }
 318
 319         // Fill structure sockaddr_in
 320         // 1) Family of protocols
 321         serverSock.sin_family = AF_INET;
 322         // 2) Number of server port
 323         serverSock.sin_port = swap16 (port);
 324         // 3) Setup ip address of server, where we want to connect
 325         memcpy (&(serverSock.sin_addr), host->h_addr, host->h_length);
 326
 327         kfree (host);
 328
 329         // Now we are able to connect to remote server
 330         if (connect (sock, (void *) &serverSock, sizeof (serverSock)) == -1) {
 331                 printf ("Connection cant be estabilished -> %s:%d\n", addr, port);
 332                 return -1;
 333         }
 334
 335         // Set socket to non-blocking mode
 336         int oldFlag = fcntl (sock, F_GETFL, 0);
 337         if (fcntl (sock, F_SETFL, oldFlag | O_NONBLOCK) == -1) {
 338                 printf ("Cant set socket to nonblocking mode\n");
 339                 return 0;
 340         }
 341
 342         znfs_dir_id = 0;
 343 #endif
 344         return 1;
 345 }
 346
 347 /* handler which is used by device management and pretty needed
 348          for communication between zexos and this filesystem */
 349 bool znfs_handler (unsigned act, char *block, unsigned n, unsigned long l)
 350 {
 351         switch (act) {
 352                 case FS_ACT_INIT:
 353                 {
 354                         return 1;
 355                 }
 356                 break;
 357                 case FS_ACT_READ:
 358                 {
 359                         return znfs_read (curr_part, dir[n].name, (vfs_content_t *) block);
 360                 }
 361                 break;
 362                 case FS_ACT_WRITE:
 363                 {
 364                         /* TODO */
 365                         //znfs_write (curr_part, block);
 366
 367                         return 0;
 368                 }
 369                 break;
 370                 case FS_ACT_CHDIR:
 371                 {
 372                         if (n == -1) {
 373                                 znfs_cd_root (curr_part);
 374                                 return 1;
 375                         }
 376
 377                         /* re-load content of current directory */
 378                         if (n == 0)
 379                                 return 1;
 380
 381                         /* go to previous directory */
 382                         if (n == 1) {
 383                                 znfs_cd (curr_part, "..");
 384                                 return 1;
 385                         }
 386
 387                         /* go to another directory */
 388                         znfs_cd (curr_part, dir[n].name);
 389
 390                         return 1;
 391                 }
 392                 break;
 393                 case FS_ACT_MKDIR:
 394                 {
 395                         znfs_create_directory (curr_part, block);
 396
 397                         return 1;
 398                 }
 399                 break;
 400                 case FS_ACT_TOUCH:
 401                 {
 402                         znfs_create_file (curr_part, block);
 403
 404                         return 1;
 405                 }
 406         }
 407
 408         return 0;
 409 }
 410 #endif