fs_test/lwext4_server.c

   1 /*
   2  * Copyright (c) 2014 Grzegorz Kostka (kostka.grzegorz@gmail.com)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <string.h>
  33 #include <stdint.h>
  34 #include <stdbool.h>
  35 #include <getopt.h>
  36 #include <time.h>
  37 #include <inttypes.h>
  38 #include <sys/time.h>
  39
  40 #ifdef WIN32
  41 #include <winsock2.h>
  42 #include <ws2tcpip.h>
  43 #include <windows.h>
  44 #else
  45 #include <sys/socket.h>
  46 #include <netinet/in.h>
  47 #include <arpa/inet.h>
  48 #include <sys/types.h>
  49 #endif
  50
  51 #include <ext4.h>
  52 #include "../blockdev/linux/ext4_filedev.h"
  53 #include "../blockdev/windows/io_raw.h"
  54
  55
  56 static int winsock_init(void);
  57 static void winsock_fini(void);
  58 static char *entry_to_str(uint8_t type);
  59
  60 #define MAX_FILES 64
  61 #define MAX_DIRS 64
  62
  63 #define MAX_RW_BUFFER (1024 * 1024)
  64 #define RW_BUFFER_PATERN ('x')
  65
  66 /**@brief   Default connection port*/
  67 static int connection_port = 1234;
  68
  69 /**@brief   Default filesystem filename.*/
  70 static char *ext4_fname = "ext2";
  71
  72 /**@brief   Verbose mode*/
  73 static bool verbose = false;
  74
  75 /**@brief   Winpart mode*/
  76 static bool winpart = false;
  77
  78 /**@brief   Blockdev handle*/
  79 static struct ext4_blockdev *bd;
  80
  81 static bool cache_wb = false;
  82
  83 static char read_buffer[MAX_RW_BUFFER];
  84 static char write_buffer[MAX_RW_BUFFER];
  85
  86 static const char *usage = "                                    \n\
  87 Welcome in lwext4_server.                                       \n\
  88 Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)  \n\
  89 Usage:                                                          \n\
  90     --image     (-i) - ext2/3/4 image file                      \n\
  91     --port      (-p) - server port                              \n\
  92     --verbose   (-v) - verbose mode                             \n\
  93     --winpart   (-w) - windows_partition mode                   \n\
  94     --cache_wb  (-c) - cache writeback_mode                     \n\
  95 \n";
  96
  97 /**@brief   Open file instance descriptor.*/
  98 struct lwext4_files {
  99         char name[255];
 100         ext4_file fd;
 101 };
 102
 103 /**@brief   Open directory instance descriptor.*/
 104 struct lwext4_dirs {
 105         char name[255];
 106         ext4_dir fd;
 107 };
 108
 109 /**@brief   Library call opcode.*/
 110 struct lwext4_op_codes {
 111         char *func;
 112 };
 113
 114 /**@brief   Library call wraper.*/
 115 struct lwext4_call {
 116         int (*lwext4_call)(char *p);
 117 };
 118
 119 /**@brief  */
 120 static struct lwext4_files file_tab[MAX_FILES];
 121
 122 /**@brief  */
 123 static struct lwext4_dirs dir_tab[MAX_DIRS];
 124
 125 /**@brief  */
 126 static struct lwext4_op_codes op_codes[] = {
 127     "device_register",
 128     "mount",
 129     "umount",
 130     "mount_point_stats",
 131     "cache_write_back",
 132     "fremove",
 133     "fopen",
 134     "fclose",
 135     "fread",
 136     "fwrite",
 137     "fseek",
 138     "ftell",
 139     "fsize",
 140     "dir_rm",
 141     "dir_mk",
 142     "dir_open",
 143     "dir_close",
 144     "dir_entry_get",
 145
 146     "multi_fcreate",
 147     "multi_fwrite",
 148     "multi_fread",
 149     "multi_fremove",
 150     "multi_dcreate",
 151     "multi_dremove",
 152     "stats_save",
 153     "stats_check",
 154 };
 155
 156 int _device_register(char *p);
 157 int _mount(char *p);
 158 int _umount(char *p);
 159 int _mount_point_stats(char *p);
 160 int _cache_write_back(char *p);
 161 int _fremove(char *p);
 162 int _fopen(char *p);
 163 int _fclose(char *p);
 164 int _fread(char *p);
 165 int _fwrite(char *p);
 166 int _fseek(char *p);
 167 int _ftell(char *p);
 168 int _fsize(char *p);
 169 int _dir_rm(char *p);
 170 int _dir_mk(char *p);
 171 int _dir_open(char *p);
 172 int _dir_close(char *p);
 173 int _dir_close(char *p);
 174 int _dir_entry_get(char *p);
 175
 176 int _multi_fcreate(char *p);
 177 int _multi_fwrite(char *p);
 178 int _multi_fread(char *p);
 179 int _multi_fremove(char *p);
 180 int _multi_dcreate(char *p);
 181 int _multi_dremove(char *p);
 182 int _stats_save(char *p);
 183 int _stats_check(char *p);
 184
 185 /**@brief  */
 186 static struct lwext4_call op_call[] = {
 187     _device_register,   /*PARAMS(3):   0 cache_mode dev_name   */
 188     _mount,             /*PARAMS(2):   dev_name mount_point    */
 189     _umount,            /*PARAMS(1):   mount_point             */
 190     _mount_point_stats, /*PARAMS(2):   mount_point, 0          */
 191     _cache_write_back,  /*PARAMS(2):   mount_point, en         */
 192     _fremove,           /*PARAMS(1):   path                    */
 193     _fopen,             /*PARAMS(2):   fid path flags          */
 194     _fclose,            /*PARAMS(1):   fid                     */
 195     _fread,             /*PARAMS(4):   fid 0 len 0             */
 196     _fwrite,            /*PARAMS(4):   fid 0 len 0             */
 197     _fseek,             /*PARAMS(2):   fid off origin          */
 198     _ftell,             /*PARAMS(2):   fid exp                 */
 199     _fsize,             /*PARAMS(2):   fid exp                 */
 200     _dir_rm,            /*PARAMS(1):   path                    */
 201     _dir_mk,            /*PARAMS(1):   path                    */
 202     _dir_open,          /*PARAMS(2):   did, path               */
 203     _dir_close,         /*PARAMS(1):   did                     */
 204     _dir_entry_get,     /*PARAMS(2):   did, exp                */
 205
 206     _multi_fcreate, /*PARAMS(3):   path prefix cnt         */
 207     _multi_fwrite,  /*PARAMS(4):   path prefix cnt size    */
 208     _multi_fread,   /*PARAMS(4):   path prefix cnt size    */
 209     _multi_fremove, /*PARAMS(2):   path prefix cnt         */
 210     _multi_dcreate, /*PARAMS(3):   path prefix cnt         */
 211     _multi_dremove, /*PARAMS(2):   path prefix             */
 212     _stats_save,    /*PARAMS(1):   path                    */
 213     _stats_check,   /*PARAMS(1):   path                    */
 214 };
 215
 216 static clock_t get_ms(void)
 217 {
 218         struct timeval t;
 219         gettimeofday(&t, NULL);
 220         return (t.tv_sec * 1000) + (t.tv_usec / 1000);
 221 }
 222
 223 /**@brief  */
 224 static int exec_op_code(char *opcode)
 225 {
 226         int i;
 227         int r = -1;
 228
 229         for (i = 0; i < sizeof(op_codes) / sizeof(op_codes[0]); ++i) {
 230
 231                 if (strncmp(op_codes[i].func, opcode, strlen(op_codes[i].func)))
 232                         continue;
 233
 234                 if (opcode[strlen(op_codes[i].func)] != ' ')
 235                         continue;
 236
 237                 printf("%s\n", opcode);
 238                 opcode += strlen(op_codes[i].func);
 239                 /*Call*/
 240
 241                 clock_t t = get_ms();
 242                 r = op_call[i].lwext4_call(opcode);
 243
 244                 printf("rc: %d, time: %ums\n", r, (unsigned int)(get_ms() - t));
 245
 246                 break;
 247         }
 248
 249         return r;
 250 }
 251
 252 static int server_open(void)
 253 {
 254         int fd = 0;
 255         struct sockaddr_in serv_addr;
 256
 257         memset(&serv_addr, 0, sizeof(serv_addr));
 258
 259         if (winsock_init() < 0) {
 260                 printf("winsock_init() error\n");
 261                 exit(-1);
 262         }
 263
 264         fd = socket(AF_INET, SOCK_STREAM, 0);
 265         if (fd < 0) {
 266                 printf("socket() error: %s\n", strerror(errno));
 267                 exit(-1);
 268         }
 269
 270         int yes = 1;
 271         if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&yes,
 272                        sizeof(int))) {
 273                 printf("setsockopt() error: %s\n", strerror(errno));
 274                 exit(-1);
 275         }
 276
 277         serv_addr.sin_family = AF_INET;
 278         serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 279         serv_addr.sin_port = htons(connection_port);
 280
 281         if (bind(fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr))) {
 282                 printf("bind() error: %s\n", strerror(errno));
 283                 exit(-1);
 284         }
 285
 286         if (listen(fd, 1)) {
 287                 printf("listen() error: %s\n", strerror(errno));
 288                 exit(-1);
 289         }
 290
 291         return fd;
 292 }
 293
 294 static bool parse_opt(int argc, char **argv)
 295 {
 296         int option_index = 0;
 297         int c;
 298
 299         static struct option long_options[] = {
 300             {"image", required_argument, 0, 'i'},
 301             {"port", required_argument, 0, 'p'},
 302             {"verbose", no_argument, 0, 'v'},
 303             {"winpart", no_argument, 0, 'w'},
 304             {"cache_wb", no_argument, 0, 'c'},
 305             {0, 0, 0, 0}};
 306
 307         while (-1 != (c = getopt_long(argc, argv, "i:p:vcw", long_options,
 308                                       &option_index))) {
 309
 310                 switch (c) {
 311                 case 'i':
 312                         ext4_fname = optarg;
 313                         break;
 314                 case 'p':
 315                         connection_port = atoi(optarg);
 316                         break;
 317                 case 'v':
 318                         verbose = true;
 319                         break;
 320                 case 'c':
 321                         cache_wb = true;
 322                         break;
 323                 case 'w':
 324                         winpart = true;
 325                         break;
 326                 default:
 327                         printf("%s", usage);
 328                         return false;
 329                 }
 330         }
 331         return true;
 332 }
 333
 334 int main(int argc, char *argv[])
 335 {
 336         int n;
 337         int listenfd;
 338         int connfd;
 339         char op_code[128];
 340
 341         if (!parse_opt(argc, argv))
 342                 return -1;
 343
 344         listenfd = server_open();
 345
 346         printf("lwext4_server: listening on port: %d\n", connection_port);
 347
 348         memset(write_buffer, RW_BUFFER_PATERN, MAX_RW_BUFFER);
 349         while (1) {
 350                 connfd = accept(listenfd, (struct sockaddr *)NULL, NULL);
 351
 352                 n = recv(connfd, op_code, sizeof(op_code), 0);
 353
 354                 if (n < 0) {
 355                         printf("recv() error: %s fd = %d\n", strerror(errno),
 356                                connfd);
 357                         break;
 358                 }
 359
 360                 op_code[n] = 0;
 361
 362                 int r = exec_op_code(op_code);
 363
 364                 n = send(connfd, (void *)&r, sizeof(r), 0);
 365                 if (n < 0) {
 366                         printf("send() error: %s fd = %d\n", strerror(errno),
 367                                connfd);
 368                         break;
 369                 }
 370
 371                 close(connfd);
 372         }
 373
 374         winsock_fini();
 375         return 0;
 376 }
 377
 378 int _device_register(char *p)
 379 {
 380         int dev;
 381         int cache_mode;
 382         char dev_name[32];
 383
 384         if (sscanf(p, "%d %d %s", &dev, &cache_mode, dev_name) != 3) {
 385                 printf("Param list error\n");
 386                 return -1;
 387         }
 388
 389 #ifdef WIN32
 390         if (winpart) {
 391                 ext4_io_raw_filename(ext4_fname);
 392                 bd = ext4_io_raw_dev_get();
 393
 394         } else
 395 #endif
 396         {
 397                 ext4_filedev_filename(ext4_fname);
 398                 bd = ext4_filedev_get();
 399         }
 400         return ext4_device_register(bd, 0, dev_name);
 401 }
 402
 403 int _mount(char *p)
 404 {
 405         char dev_name[32];
 406         char mount_point[32];
 407         int rc;
 408
 409         if (sscanf(p, "%s %s", dev_name, mount_point) != 2) {
 410                 printf("Param list error\n");
 411                 return -1;
 412         }
 413
 414         if (verbose)
 415                 ext4_dmask_set(DEBUG_ALL);
 416
 417         rc = ext4_mount(dev_name, mount_point);
 418         if (rc != EOK)
 419                 return rc;
 420
 421         rc = ext4_recover(mount_point);
 422         if (rc != EOK && rc != ENOTSUP)
 423                 return rc;
 424
 425         rc = ext4_journal_start(mount_point);
 426         if (rc != EOK)
 427                 return rc;
 428
 429         if (cache_wb)
 430                 ext4_cache_write_back(mount_point, 1);
 431         return rc;
 432 }
 433
 434 int _umount(char *p)
 435 {
 436         char mount_point[32];
 437         int rc;
 438
 439         if (sscanf(p, "%s", mount_point) != 1) {
 440                 printf("Param list error\n");
 441                 return -1;
 442         }
 443
 444         if (cache_wb)
 445                 ext4_cache_write_back(mount_point, 0);
 446
 447         rc = ext4_journal_stop(mount_point);
 448         if (rc != EOK)
 449                 return rc;
 450
 451         rc = ext4_umount(mount_point);
 452         if (rc != EOK)
 453                 return rc;
 454
 455         return rc;
 456 }
 457
 458 int _mount_point_stats(char *p)
 459 {
 460         char mount_point[32];
 461         int d;
 462         int rc;
 463         struct ext4_mount_stats stats;
 464
 465         if (sscanf(p, "%s %d", mount_point, &d) != 2) {
 466                 printf("Param list error\n");
 467                 return -1;
 468         }
 469
 470         rc = ext4_mount_point_stats(mount_point, &stats);
 471
 472         if (rc != EOK)
 473                 return rc;
 474
 475         if (verbose) {
 476                 printf("\tinodes_count = %" PRIu32"\n", stats.inodes_count);
 477                 printf("\tfree_inodes_count = %" PRIu32"\n",
 478                                 stats.free_inodes_count);
 479                 printf("\tblocks_count = %" PRIu64"\n", stats.blocks_count);
 480                 printf("\tfree_blocks_count = %" PRIu64"\n",
 481                                 stats.free_blocks_count);
 482                 printf("\tblock_size = %" PRIu32"\n", stats.block_size);
 483                 printf("\tblock_group_count = %" PRIu32"\n",
 484                                 stats.block_group_count);
 485                 printf("\tblocks_per_group = %" PRIu32"\n",
 486                                 stats.blocks_per_group);
 487                 printf("\tinodes_per_group = %" PRIu32"\n",
 488                                 stats.inodes_per_group);
 489                 printf("\tvolume_name = %s\n", stats.volume_name);
 490         }
 491
 492         return rc;
 493 }
 494
 495 int _cache_write_back(char *p)
 496 {
 497         char mount_point[32];
 498         int en;
 499
 500         if (sscanf(p, "%s %d", mount_point, &en) != 2) {
 501                 printf("Param list error\n");
 502                 return -1;
 503         }
 504
 505         return ext4_cache_write_back(mount_point, en);
 506 }
 507
 508 int _fremove(char *p)
 509 {
 510         char path[255];
 511
 512         if (sscanf(p, "%s", path) != 1) {
 513                 printf("Param list error\n");
 514                 return -1;
 515         }
 516
 517         return ext4_fremove(path);
 518 }
 519
 520 int _fopen(char *p)
 521 {
 522         int fid = MAX_FILES;
 523         char path[256];
 524         char flags[8];
 525         int rc;
 526
 527         if (sscanf(p, "%d %s %s", &fid, path, flags) != 3) {
 528                 printf("Param list error\n");
 529                 return -1;
 530         }
 531
 532         if (!(fid < MAX_FILES)) {
 533                 printf("File id too big\n");
 534                 return -1;
 535         }
 536
 537         rc = ext4_fopen(&file_tab[fid].fd, path, flags);
 538
 539         if (rc == EOK)
 540                 strcpy(file_tab[fid].name, path);
 541
 542         return rc;
 543 }
 544
 545 int _fclose(char *p)
 546 {
 547         int fid = MAX_FILES;
 548         int rc;
 549
 550         if (sscanf(p, "%d", &fid) != 1) {
 551                 printf("Param list error\n");
 552                 return -1;
 553         }
 554
 555         if (!(fid < MAX_FILES)) {
 556                 printf("File id too big\n");
 557                 return -1;
 558         }
 559
 560         if (file_tab[fid].name[0] == 0) {
 561                 printf("File id empty\n");
 562                 return -1;
 563         }
 564
 565         rc = ext4_fclose(&file_tab[fid].fd);
 566
 567         if (rc == EOK)
 568                 file_tab[fid].name[0] = 0;
 569
 570         return rc;
 571 }
 572
 573 int _fread(char *p)
 574 {
 575         int fid = MAX_FILES;
 576         int len;
 577         int d;
 578         int rc;
 579         size_t rb;
 580
 581         if (sscanf(p, "%d %d %d %d", &fid, &d, &len, &d) != 4) {
 582                 printf("Param list error\n");
 583                 return -1;
 584         }
 585
 586         if (!(fid < MAX_FILES)) {
 587                 printf("File id too big\n");
 588                 return -1;
 589         }
 590
 591         if (file_tab[fid].name[0] == 0) {
 592                 printf("File id empty\n");
 593                 return -1;
 594         }
 595
 596         while (len) {
 597                 d = len > MAX_RW_BUFFER ? MAX_RW_BUFFER : len;
 598
 599                 memset(read_buffer, 0, MAX_RW_BUFFER);
 600                 rc = ext4_fread(&file_tab[fid].fd, read_buffer, d, &rb);
 601
 602                 if (rc != EOK)
 603                         break;
 604
 605                 if (rb != d) {
 606                         printf("Read count error\n");
 607                         return -1;
 608                 }
 609
 610                 if (memcmp(read_buffer, write_buffer, d)) {
 611                         printf("Read compare error\n");
 612                         return -1;
 613                 }
 614
 615                 len -= d;
 616         }
 617
 618         return rc;
 619 }
 620
 621 int _fwrite(char *p)
 622 {
 623         int fid = MAX_FILES;
 624         int d;
 625         int rc;
 626
 627         int len;
 628         size_t wb;
 629
 630         if (sscanf(p, "%d %d %d %d", &fid, &d, &len, &d) != 4) {
 631                 printf("Param list error\n");
 632                 return -1;
 633         }
 634
 635         if (!(fid < MAX_FILES)) {
 636                 printf("File id too big\n");
 637                 return -1;
 638         }
 639
 640         if (file_tab[fid].name[0] == 0) {
 641                 printf("File id empty\n");
 642                 return -1;
 643         }
 644
 645         while (len) {
 646                 d = len > MAX_RW_BUFFER ? MAX_RW_BUFFER : len;
 647                 rc = ext4_fwrite(&file_tab[fid].fd, write_buffer, d, &wb);
 648
 649                 if (rc != EOK)
 650                         break;
 651
 652                 if (wb != d) {
 653                         printf("Write count error\n");
 654                         return -1;
 655                 }
 656
 657                 len -= d;
 658         }
 659
 660         return rc;
 661 }
 662
 663 int _fseek(char *p)
 664 {
 665         int fid = MAX_FILES;
 666         int off;
 667         int origin;
 668
 669         if (sscanf(p, "%d %d %d", &fid, &off, &origin) != 3) {
 670                 printf("Param list error\n");
 671                 return -1;
 672         }
 673
 674         if (!(fid < MAX_FILES)) {
 675                 printf("File id too big\n");
 676                 return -1;
 677         }
 678
 679         if (file_tab[fid].name[0] == 0) {
 680                 printf("File id empty\n");
 681                 return -1;
 682         }
 683
 684         return ext4_fseek(&file_tab[fid].fd, off, origin);
 685 }
 686
 687 int _ftell(char *p)
 688 {
 689         int fid = MAX_FILES;
 690         uint32_t exp_pos;
 691
 692         if (sscanf(p, "%d %u", &fid, &exp_pos) != 2) {
 693                 printf("Param list error\n");
 694                 return -1;
 695         }
 696
 697         if (!(fid < MAX_FILES)) {
 698                 printf("File id too big\n");
 699                 return -1;
 700         }
 701
 702         if (file_tab[fid].name[0] == 0) {
 703                 printf("File id empty\n");
 704                 return -1;
 705         }
 706
 707         if (exp_pos != ext4_ftell(&file_tab[fid].fd)) {
 708                 printf("Expected filepos error\n");
 709                 return -1;
 710         }
 711
 712         return EOK;
 713 }
 714
 715 int _fsize(char *p)
 716 {
 717         int fid = MAX_FILES;
 718         uint32_t exp_size;
 719
 720         if (sscanf(p, "%d %u", &fid, &exp_size) != 2) {
 721                 printf("Param list error\n");
 722                 return -1;
 723         }
 724
 725         if (!(fid < MAX_FILES)) {
 726                 printf("File id too big\n");
 727                 return -1;
 728         }
 729
 730         if (file_tab[fid].name[0] == 0) {
 731                 printf("File id empty\n");
 732                 return -1;
 733         }
 734
 735         if (exp_size != ext4_fsize(&file_tab[fid].fd)) {
 736                 printf("Expected filesize error\n");
 737                 return -1;
 738         }
 739
 740         return EOK;
 741 }
 742
 743 int _dir_rm(char *p)
 744 {
 745         char path[255];
 746
 747         if (sscanf(p, "%s", path) != 1) {
 748                 printf("Param list error\n");
 749                 return -1;
 750         }
 751
 752         return ext4_dir_rm(path);
 753 }
 754
 755 int _dir_mk(char *p)
 756 {
 757         char path[255];
 758
 759         if (sscanf(p, "%s", path) != 1) {
 760                 printf("Param list error\n");
 761                 return -1;
 762         }
 763
 764         return ext4_dir_mk(path);
 765 }
 766
 767 int _dir_open(char *p)
 768 {
 769         int did = MAX_DIRS;
 770         char path[255];
 771         int rc;
 772
 773         if (sscanf(p, "%d %s", &did, path) != 2) {
 774                 printf("Param list error\n");
 775                 return -1;
 776         }
 777
 778         if (!(did < MAX_DIRS)) {
 779                 printf("Dir id too big\n");
 780                 return -1;
 781         }
 782
 783         rc = ext4_dir_open(&dir_tab[did].fd, path);
 784
 785         if (rc == EOK)
 786                 strcpy(dir_tab[did].name, path);
 787
 788         return rc;
 789 }
 790
 791 int _dir_close(char *p)
 792 {
 793         int did = MAX_DIRS;
 794         int rc;
 795
 796         if (sscanf(p, "%d", &did) != 1) {
 797                 printf("Param list error\n");
 798                 return -1;
 799         }
 800
 801         if (!(did < MAX_DIRS)) {
 802                 printf("Dir id too big\n");
 803                 return -1;
 804         }
 805
 806         if (dir_tab[did].name[0] == 0) {
 807                 printf("Dir id empty\n");
 808                 return -1;
 809         }
 810
 811         rc = ext4_dir_close(&dir_tab[did].fd);
 812
 813         if (rc == EOK)
 814                 dir_tab[did].name[0] = 0;
 815
 816         return rc;
 817 }
 818
 819 int _dir_entry_get(char *p)
 820 {
 821         int did = MAX_DIRS;
 822         int exp;
 823         char name[256];
 824
 825         if (sscanf(p, "%d %d", &did, &exp) != 2) {
 826                 printf("Param list error\n");
 827                 return -1;
 828         }
 829
 830         if (!(did < MAX_DIRS)) {
 831                 printf("Dir id too big\n");
 832                 return -1;
 833         }
 834
 835         if (dir_tab[did].name[0] == 0) {
 836                 printf("Dir id empty\n");
 837                 return -1;
 838         }
 839
 840         int idx = 0;
 841         const ext4_direntry *d;
 842
 843         while ((d = ext4_dir_entry_next(&dir_tab[did].fd)) != NULL) {
 844
 845                 idx++;
 846                 memcpy(name, d->name, d->name_length);
 847                 name[d->name_length] = 0;
 848                 if (verbose) {
 849                         printf("\t%s %s\n", entry_to_str(d->inode_type), name);
 850                 }
 851         }
 852
 853         if (idx < 2) {
 854                 printf("Minumum dir entry error\n");
 855                 return -1;
 856         }
 857
 858         if ((idx - 2) != exp) {
 859                 printf("Expected dir entry error\n");
 860                 return -1;
 861         }
 862
 863         return EOK;
 864 }
 865
 866 int _multi_fcreate(char *p)
 867 {
 868         char path[256];
 869         char path1[256];
 870         char prefix[32];
 871         int cnt;
 872         int rc;
 873         int i;
 874         ext4_file fd;
 875
 876         if (sscanf(p, "%s %s %d", path, prefix, &cnt) != 3) {
 877                 printf("Param list error\n");
 878                 return -1;
 879         }
 880
 881         for (i = 0; i < cnt; ++i) {
 882                 sprintf(path1, "%s%s%d", path, prefix, i);
 883                 rc = ext4_fopen(&fd, path1, "wb+");
 884
 885                 if (rc != EOK)
 886                         break;
 887         }
 888
 889         return rc;
 890 }
 891
 892 int _multi_fwrite(char *p)
 893 {
 894         char path[256];
 895         char path1[256];
 896         char prefix[32];
 897         int cnt, i;
 898         int len, ll;
 899         int rc;
 900         size_t d, wb;
 901         ext4_file fd;
 902
 903         if (sscanf(p, "%s %s %d %d", path, prefix, &cnt, &ll) != 4) {
 904                 printf("Param list error\n");
 905                 return -1;
 906         }
 907
 908         for (i = 0; i < cnt; ++i) {
 909                 sprintf(path1, "%s%s%d", path, prefix, i);
 910                 rc = ext4_fopen(&fd, path1, "rb+");
 911
 912                 if (rc != EOK)
 913                         break;
 914
 915                 len = ll;
 916                 while (len) {
 917                         d = len > MAX_RW_BUFFER ? MAX_RW_BUFFER : len;
 918                         rc = ext4_fwrite(&fd, write_buffer, d, &wb);
 919
 920                         if (rc != EOK)
 921                                 break;
 922
 923                         if (wb != d) {
 924                                 printf("Write count error\n");
 925                                 return -1;
 926                         }
 927
 928                         len -= d;
 929                 }
 930         }
 931
 932         return rc;
 933 }
 934
 935 int _multi_fread(char *p)
 936 {
 937         char path[256];
 938         char path1[256];
 939         char prefix[32];
 940         int cnt;
 941         int len, ll;
 942         int rc ,i, d;
 943         size_t rb;
 944         ext4_file fd;
 945
 946         if (sscanf(p, "%s %s %d %d", path, prefix, &cnt, &ll) != 4) {
 947                 printf("Param list error\n");
 948                 return -1;
 949         }
 950
 951         for (i = 0; i < cnt; ++i) {
 952                 sprintf(path1, "%s%s%d", path, prefix, i);
 953                 rc = ext4_fopen(&fd, path1, "rb+");
 954
 955                 if (rc != EOK)
 956                         break;
 957
 958                 len = ll;
 959                 while (len) {
 960                         d = len > MAX_RW_BUFFER ? MAX_RW_BUFFER : len;
 961
 962                         memset(read_buffer, 0, MAX_RW_BUFFER);
 963                         rc = ext4_fread(&fd, read_buffer, d, &rb);
 964
 965                         if (rc != EOK)
 966                                 break;
 967
 968                         if (rb != d) {
 969                                 printf("Read count error\n");
 970                                 return -1;
 971                         }
 972
 973                         if (memcmp(read_buffer, write_buffer, d)) {
 974                                 printf("Read compare error\n");
 975                                 return -1;
 976                         }
 977
 978                         len -= d;
 979                 }
 980         }
 981
 982         return rc;
 983 }
 984
 985 int _multi_fremove(char *p)
 986 {
 987         char path[256];
 988         char path1[256];
 989         char prefix[32];
 990         int cnt, i, rc;
 991
 992         if (sscanf(p, "%s %s %d", path, prefix, &cnt) != 3) {
 993                 printf("Param list error\n");
 994                 return -1;
 995         }
 996
 997         for (i = 0; i < cnt; ++i) {
 998                 sprintf(path1, "%s%s%d", path, prefix, i);
 999                 rc = ext4_fremove(path1);
1000                 if (rc != EOK)
1001                         break;
1002         }
1003
1004         return rc;
1005 }
1006
1007 int _multi_dcreate(char *p)
1008 {
1009         char path[256];
1010         char path1[256];
1011         char prefix[32];
1012         int cnt, i, rc;
1013
1014         if (sscanf(p, "%s %s %d", path, prefix, &cnt) != 3) {
1015                 printf("Param list error\n");
1016                 return -1;
1017         }
1018
1019         for (i = 0; i < cnt; ++i) {
1020                 sprintf(path1, "%s%s%d", path, prefix, i);
1021                 rc = ext4_dir_mk(path1);
1022                 if (rc != EOK)
1023                         break;
1024         }
1025
1026         return rc;
1027 }
1028
1029 int _multi_dremove(char *p)
1030 {
1031         char path[256];
1032         char path1[256];
1033         char prefix[32];
1034         int cnt, i, rc;
1035
1036         if (sscanf(p, "%s %s %d", path, prefix, &cnt) != 3) {
1037                 printf("Param list error\n");
1038                 return -1;
1039         }
1040
1041         for (i = 0; i < cnt; ++i) {
1042                 sprintf(path1, "%s%s%d", path, prefix, i);
1043                 rc = ext4_dir_rm(path1);
1044                 if (rc != EOK)
1045                         break;
1046         }
1047
1048         return rc;
1049 }
1050
1051 struct ext4_mount_stats saved_stats;
1052
1053 int _stats_save(char *p)
1054 {
1055         char path[256];
1056
1057         if (sscanf(p, "%s", path) != 1) {
1058                 printf("Param list error\n");
1059                 return -1;
1060         }
1061
1062         return ext4_mount_point_stats(path, &saved_stats);
1063 }
1064
1065 int _stats_check(char *p)
1066 {
1067         char path[256];
1068         int rc;
1069
1070         struct ext4_mount_stats actual_stats;
1071
1072         if (sscanf(p, "%s", path) != 1) {
1073                 printf("Param list error\n");
1074                 return -1;
1075         }
1076
1077         rc = ext4_mount_point_stats(path, &actual_stats);
1078
1079         if (rc != EOK)
1080                 return rc;
1081
1082         if (memcmp(&saved_stats, &actual_stats,
1083                    sizeof(struct ext4_mount_stats))) {
1084                 if (verbose) {
1085                         printf("\tMount point stats error:\n");
1086                         printf("\tsaved_stats:\n");
1087                         printf("\tinodes_count = %" PRIu32"\n",
1088                                saved_stats.inodes_count);
1089                         printf("\tfree_inodes_count = %" PRIu32"\n",
1090                                saved_stats.free_inodes_count);
1091                         printf("\tblocks_count = %" PRIu64"\n",
1092                                saved_stats.blocks_count);
1093                         printf("\tfree_blocks_count = %" PRIu64"\n",
1094                                saved_stats.free_blocks_count);
1095                         printf("\tblock_size = %" PRIu32"\n",
1096                                         saved_stats.block_size);
1097                         printf("\tblock_group_count = %" PRIu32"\n",
1098                                saved_stats.block_group_count);
1099                         printf("\tblocks_per_group = %" PRIu32"\n",
1100                                saved_stats.blocks_per_group);
1101                         printf("\tinodes_per_group = %" PRIu32"\n",
1102                                saved_stats.inodes_per_group);
1103                         printf("\tvolume_name = %s\n", saved_stats.volume_name);
1104                         printf("\tactual_stats:\n");
1105                         printf("\tinodes_count = %" PRIu32"\n",
1106                                actual_stats.inodes_count);
1107                         printf("\tfree_inodes_count = %" PRIu32"\n",
1108                                actual_stats.free_inodes_count);
1109                         printf("\tblocks_count = %" PRIu64"\n",
1110                                actual_stats.blocks_count);
1111                         printf("\tfree_blocks_count = %" PRIu64"\n",
1112                                actual_stats.free_blocks_count);
1113                         printf("\tblock_size = %d\n", actual_stats.block_size);
1114                         printf("\tblock_group_count = %" PRIu32"\n",
1115                                actual_stats.block_group_count);
1116                         printf("\tblocks_per_group = %" PRIu32"\n",
1117                                actual_stats.blocks_per_group);
1118                         printf("\tinodes_per_group = %" PRIu32"\n",
1119                                actual_stats.inodes_per_group);
1120                         printf("\tvolume_name = %s\n",
1121                                actual_stats.volume_name);
1122                 }
1123                 return -1;
1124         }
1125
1126         return rc;
1127 }
1128
1129 static char *entry_to_str(uint8_t type)
1130 {
1131         switch (type) {
1132         case EXT4_DE_UNKNOWN:
1133                 return "[unk] ";
1134         case EXT4_DE_REG_FILE:
1135                 return "[fil] ";
1136         case EXT4_DE_DIR:
1137                 return "[dir] ";
1138         case EXT4_DE_CHRDEV:
1139                 return "[cha] ";
1140         case EXT4_DE_BLKDEV:
1141                 return "[blk] ";
1142         case EXT4_DE_FIFO:
1143                 return "[fif] ";
1144         case EXT4_DE_SOCK:
1145                 return "[soc] ";
1146         case EXT4_DE_SYMLINK:
1147                 return "[sym] ";
1148         default:
1149                 break;
1150         }
1151         return "[???]";
1152 }
1153
1154 static int winsock_init(void)
1155 {
1156 #if WIN32
1157         int rc;
1158         static WSADATA wsaData;
1159         rc = WSAStartup(MAKEWORD(2, 2), &wsaData);
1160         if (rc != 0) {
1161                 return -1;
1162         }
1163 #endif
1164         return 0;
1165 }
1166
1167 static void winsock_fini(void)
1168 {
1169 #if WIN32
1170         WSACleanup();
1171 #endif
1172 }