kernel/drivers/fs/znfs.c

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