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 <sys/time.h>
  38
  39 #ifdef WIN32
  40 #include <winsock2.h>
  41 #include <ws2tcpip.h>
  42 #include <windows.h>
  43 #else
  44 #include <sys/socket.h>
  45 #include <netinet/in.h>
  46 #include <arpa/inet.h>
  47 #include <sys/types.h>
  48 #endif
  49
  50 #include "../blockdev/linux/ext4_filedev.h"
  51 #include "../blockdev/windows/io_raw.h"
  52
  53 #include <ext4.h>
  54 #include <errno.h>
  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 int verbose = 0;
  74
  75 /**@brief   Winpart mode*/
  76 static int winpart = 0;
  77
  78 /**@brief   Blockdev handle*/
  79 static struct ext4_blockdev *bd;
  80
  81 static int cache_wb = 0;
  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", required_argument, 0, 'v'},
 303             {"winpart", required_argument, 0, 'w'},
 304             {"cache_wb", required_argument, 0, 'c'},
 305             {0, 0, 0, 0}};
 306
 307         while (-1 != (c = getopt_long(argc, argv, "c:i:p:v:w:", 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 = atoi(optarg);
 319                         break;
 320                 case 'c':
 321                         cache_wb = atoi(optarg);
 322                         break;
 323                 case 'w':
 324                         winpart = atoi(optarg);
 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         rc = ext4_mount(dev_name, mount_point);
 415         if (cache_wb)
 416                 ext4_cache_write_back(mount_point, 1);
 417         return rc;
 418 }
 419
 420 int _umount(char *p)
 421 {
 422         char mount_point[32];
 423
 424         if (sscanf(p, "%s", mount_point) != 1) {
 425                 printf("Param list error\n");
 426                 return -1;
 427         }
 428
 429         if (cache_wb)
 430                 ext4_cache_write_back(mount_point, 0);
 431
 432         return ext4_umount(mount_point);
 433 }
 434
 435 int _mount_point_stats(char *p)
 436 {
 437         char mount_point[32];
 438         int d;
 439         int rc;
 440         struct ext4_mount_stats stats;
 441
 442         if (sscanf(p, "%s %d", mount_point, &d) != 2) {
 443                 printf("Param list error\n");
 444                 return -1;
 445         }
 446
 447         rc = ext4_mount_point_stats(mount_point, &stats);
 448
 449         if (rc != EOK)
 450                 return rc;
 451
 452         if (verbose) {
 453                 printf("\tinodes_count = %d\n", stats.inodes_count);
 454                 printf("\tfree_inodes_count = %d\n", stats.free_inodes_count);
 455                 printf("\tblocks_count = %llu\n", stats.blocks_count);
 456                 printf("\tfree_blocks_count = %llu\n", stats.free_blocks_count);
 457
 458                 printf("\tblock_size = %d\n", stats.block_size);
 459                 printf("\tblock_group_count = %d\n", stats.block_group_count);
 460                 printf("\tblocks_per_group = %d\n", stats.blocks_per_group);
 461                 printf("\tinodes_per_group = %d\n", stats.inodes_per_group);
 462
 463                 printf("\tvolume_name = %s\n", stats.volume_name);
 464         }
 465
 466         return rc;
 467 }
 468
 469 int _cache_write_back(char *p)
 470 {
 471         char mount_point[32];
 472         int en;
 473
 474         if (sscanf(p, "%s %d", mount_point, &en) != 2) {
 475                 printf("Param list error\n");
 476                 return -1;
 477         }
 478
 479         return ext4_cache_write_back(mount_point, en);
 480 }
 481
 482 int _fremove(char *p)
 483 {
 484         char path[255];
 485
 486         if (sscanf(p, "%s", path) != 1) {
 487                 printf("Param list error\n");
 488                 return -1;
 489         }
 490
 491         return ext4_fremove(path);
 492 }
 493
 494 int _fopen(char *p)
 495 {
 496         int fid = MAX_FILES;
 497         char path[256];
 498         char flags[8];
 499         int rc;
 500
 501         if (sscanf(p, "%d %s %s", &fid, path, flags) != 3) {
 502                 printf("Param list error\n");
 503                 return -1;
 504         }
 505
 506         if (!(fid < MAX_FILES)) {
 507                 printf("File id too big\n");
 508                 return -1;
 509         }
 510
 511         rc = ext4_fopen(&file_tab[fid].fd, path, flags);
 512
 513         if (rc == EOK)
 514                 strcpy(file_tab[fid].name, path);
 515
 516         return rc;
 517 }
 518
 519 int _fclose(char *p)
 520 {
 521         int fid = MAX_FILES;
 522         int rc;
 523
 524         if (sscanf(p, "%d", &fid) != 1) {
 525                 printf("Param list error\n");
 526                 return -1;
 527         }
 528
 529         if (!(fid < MAX_FILES)) {
 530                 printf("File id too big\n");
 531                 return -1;
 532         }
 533
 534         if (file_tab[fid].name[0] == 0) {
 535                 printf("File id empty\n");
 536                 return -1;
 537         }
 538
 539         rc = ext4_fclose(&file_tab[fid].fd);
 540
 541         if (rc == EOK)
 542                 file_tab[fid].name[0] = 0;
 543
 544         return rc;
 545 }
 546
 547 int _fread(char *p)
 548 {
 549         int fid = MAX_FILES;
 550         int len;
 551         int d;
 552         int rc;
 553         size_t rb;
 554
 555         if (sscanf(p, "%d %d %d %d", &fid, &d, &len, &d) != 4) {
 556                 printf("Param list error\n");
 557                 return -1;
 558         }
 559
 560         if (!(fid < MAX_FILES)) {
 561                 printf("File id too big\n");
 562                 return -1;
 563         }
 564
 565         if (file_tab[fid].name[0] == 0) {
 566                 printf("File id empty\n");
 567                 return -1;
 568         }
 569
 570         while (len) {
 571                 d = len > MAX_RW_BUFFER ? MAX_RW_BUFFER : len;
 572
 573                 memset(read_buffer, 0, MAX_RW_BUFFER);
 574                 rc = ext4_fread(&file_tab[fid].fd, read_buffer, d, &rb);
 575
 576                 if (rc != EOK)
 577                         break;
 578
 579                 if (rb != d) {
 580                         printf("Read count error\n");
 581                         return -1;
 582                 }
 583
 584                 if (memcmp(read_buffer, write_buffer, d)) {
 585                         printf("Read compare error\n");
 586                         return -1;
 587                 }
 588
 589                 len -= d;
 590         }
 591
 592         return rc;
 593 }
 594
 595 int _fwrite(char *p)
 596 {
 597         int fid = MAX_FILES;
 598         int d;
 599         int rc;
 600
 601         size_t len;
 602         size_t wb;
 603
 604         if (sscanf(p, "%d %d %d %d", &fid, &d, &len, &d) != 4) {
 605                 printf("Param list error\n");
 606                 return -1;
 607         }
 608
 609         if (!(fid < MAX_FILES)) {
 610                 printf("File id too big\n");
 611                 return -1;
 612         }
 613
 614         if (file_tab[fid].name[0] == 0) {
 615                 printf("File id empty\n");
 616                 return -1;
 617         }
 618
 619         while (len) {
 620                 d = len > MAX_RW_BUFFER ? MAX_RW_BUFFER : len;
 621                 rc = ext4_fwrite(&file_tab[fid].fd, write_buffer, d, &wb);
 622
 623                 if (rc != EOK)
 624                         break;
 625
 626                 if (wb != d) {
 627                         printf("Write count error\n");
 628                         return -1;
 629                 }
 630
 631                 len -= d;
 632         }
 633
 634         return rc;
 635 }
 636
 637 int _fseek(char *p)
 638 {
 639         int fid = MAX_FILES;
 640         int off;
 641         int origin;
 642
 643         if (sscanf(p, "%d %d %d", &fid, &off, &origin) != 3) {
 644                 printf("Param list error\n");
 645                 return -1;
 646         }
 647
 648         if (!(fid < MAX_FILES)) {
 649                 printf("File id too big\n");
 650                 return -1;
 651         }
 652
 653         if (file_tab[fid].name[0] == 0) {
 654                 printf("File id empty\n");
 655                 return -1;
 656         }
 657
 658         return ext4_fseek(&file_tab[fid].fd, off, origin);
 659 }
 660
 661 int _ftell(char *p)
 662 {
 663         int fid = MAX_FILES;
 664         uint32_t exp_pos;
 665
 666         if (sscanf(p, "%d %u", &fid, &exp_pos) != 2) {
 667                 printf("Param list error\n");
 668                 return -1;
 669         }
 670
 671         if (!(fid < MAX_FILES)) {
 672                 printf("File id too big\n");
 673                 return -1;
 674         }
 675
 676         if (file_tab[fid].name[0] == 0) {
 677                 printf("File id empty\n");
 678                 return -1;
 679         }
 680
 681         if (exp_pos != ext4_ftell(&file_tab[fid].fd)) {
 682                 printf("Expected filepos error\n");
 683                 return -1;
 684         }
 685
 686         return EOK;
 687 }
 688
 689 int _fsize(char *p)
 690 {
 691         int fid = MAX_FILES;
 692         uint32_t exp_size;
 693
 694         if (sscanf(p, "%d %u", &fid, &exp_size) != 2) {
 695                 printf("Param list error\n");
 696                 return -1;
 697         }
 698
 699         if (!(fid < MAX_FILES)) {
 700                 printf("File id too big\n");
 701                 return -1;
 702         }
 703
 704         if (file_tab[fid].name[0] == 0) {
 705                 printf("File id empty\n");
 706                 return -1;
 707         }
 708
 709         if (exp_size != ext4_fsize(&file_tab[fid].fd)) {
 710                 printf("Expected filesize error\n");
 711                 return -1;
 712         }
 713
 714         return EOK;
 715 }
 716
 717 int _dir_rm(char *p)
 718 {
 719         char path[255];
 720
 721         if (sscanf(p, "%s", path) != 1) {
 722                 printf("Param list error\n");
 723                 return -1;
 724         }
 725
 726         return ext4_dir_rm(path);
 727 }
 728
 729 int _dir_mk(char *p)
 730 {
 731         char path[255];
 732
 733         if (sscanf(p, "%s", path) != 1) {
 734                 printf("Param list error\n");
 735                 return -1;
 736         }
 737
 738         return ext4_dir_mk(path);
 739 }
 740
 741 int _dir_open(char *p)
 742 {
 743         int did = MAX_DIRS;
 744         char path[255];
 745         int rc;
 746
 747         if (sscanf(p, "%d %s", &did, path) != 2) {
 748                 printf("Param list error\n");
 749                 return -1;
 750         }
 751
 752         if (!(did < MAX_DIRS)) {
 753                 printf("Dir id too big\n");
 754                 return -1;
 755         }
 756
 757         rc = ext4_dir_open(&dir_tab[did].fd, path);
 758
 759         if (rc == EOK)
 760                 strcpy(dir_tab[did].name, path);
 761
 762         return rc;
 763 }
 764
 765 int _dir_close(char *p)
 766 {
 767         int did = MAX_DIRS;
 768         int rc;
 769
 770         if (sscanf(p, "%d", &did) != 1) {
 771                 printf("Param list error\n");
 772                 return -1;
 773         }
 774
 775         if (!(did < MAX_DIRS)) {
 776                 printf("Dir id too big\n");
 777                 return -1;
 778         }
 779
 780         if (dir_tab[did].name[0] == 0) {
 781                 printf("Dir id empty\n");
 782                 return -1;
 783         }
 784
 785         rc = ext4_dir_close(&dir_tab[did].fd);
 786
 787         if (rc == EOK)
 788                 dir_tab[did].name[0] = 0;
 789
 790         return rc;
 791 }
 792
 793 int _dir_entry_get(char *p)
 794 {
 795         int did = MAX_DIRS;
 796         int exp;
 797         char name[256];
 798
 799         if (sscanf(p, "%d %d", &did, &exp) != 2) {
 800                 printf("Param list error\n");
 801                 return -1;
 802         }
 803
 804         if (!(did < MAX_DIRS)) {
 805                 printf("Dir id too big\n");
 806                 return -1;
 807         }
 808
 809         if (dir_tab[did].name[0] == 0) {
 810                 printf("Dir id empty\n");
 811                 return -1;
 812         }
 813
 814         int idx = 0;
 815         const ext4_direntry *d;
 816
 817         while ((d = ext4_dir_entry_next(&dir_tab[did].fd)) != NULL) {
 818
 819                 idx++;
 820                 memcpy(name, d->name, d->name_length);
 821                 name[d->name_length] = 0;
 822                 if (verbose) {
 823                         printf("\t%s %s\n", entry_to_str(d->inode_type), name);
 824                 }
 825         }
 826
 827         if (idx < 2) {
 828                 printf("Minumum dir entry error\n");
 829                 return -1;
 830         }
 831
 832         if ((idx - 2) != exp) {
 833                 printf("Expected dir entry error\n");
 834                 return -1;
 835         }
 836
 837         return EOK;
 838 }
 839
 840 int _multi_fcreate(char *p)
 841 {
 842         char path[256];
 843         char path1[256];
 844         char prefix[32];
 845         int cnt;
 846         int rc;
 847         int i;
 848         ext4_file fd;
 849
 850         if (sscanf(p, "%s %s %d", path, prefix, &cnt) != 3) {
 851                 printf("Param list error\n");
 852                 return -1;
 853         }
 854
 855         for (i = 0; i < cnt; ++i) {
 856                 sprintf(path1, "%s%s%d", path, prefix, i);
 857                 rc = ext4_fopen(&fd, path1, "wb+");
 858
 859                 if (rc != EOK)
 860                         break;
 861         }
 862
 863         return rc;
 864 }
 865
 866 int _multi_fwrite(char *p)
 867 {
 868         char path[256];
 869         char path1[256];
 870         char prefix[32];
 871         int cnt, i;
 872         int len, ll;
 873         int rc;
 874         size_t d, wb;
 875         ext4_file fd;
 876
 877         if (sscanf(p, "%s %s %d %d", path, prefix, &cnt, &ll) != 4) {
 878                 printf("Param list error\n");
 879                 return -1;
 880         }
 881
 882         for (i = 0; i < cnt; ++i) {
 883                 sprintf(path1, "%s%s%d", path, prefix, i);
 884                 rc = ext4_fopen(&fd, path1, "rb+");
 885
 886                 if (rc != EOK)
 887                         break;
 888
 889                 len = ll;
 890                 while (len) {
 891                         d = len > MAX_RW_BUFFER ? MAX_RW_BUFFER : len;
 892                         rc = ext4_fwrite(&fd, write_buffer, d, &wb);
 893
 894                         if (rc != EOK)
 895                                 break;
 896
 897                         if (wb != d) {
 898                                 printf("Write count error\n");
 899                                 return -1;
 900                         }
 901
 902                         len -= d;
 903                 }
 904         }
 905
 906         return rc;
 907 }
 908
 909 int _multi_fread(char *p)
 910 {
 911         char path[256];
 912         char path1[256];
 913         char prefix[32];
 914         int cnt;
 915         int len, ll;
 916         int rc ,i, d;
 917         size_t rb;
 918         ext4_file fd;
 919
 920         if (sscanf(p, "%s %s %d %d", path, prefix, &cnt, &ll) != 4) {
 921                 printf("Param list error\n");
 922                 return -1;
 923         }
 924
 925         for (i = 0; i < cnt; ++i) {
 926                 sprintf(path1, "%s%s%d", path, prefix, i);
 927                 rc = ext4_fopen(&fd, path1, "rb+");
 928
 929                 if (rc != EOK)
 930                         break;
 931
 932                 len = ll;
 933                 while (len) {
 934                         d = len > MAX_RW_BUFFER ? MAX_RW_BUFFER : len;
 935
 936                         memset(read_buffer, 0, MAX_RW_BUFFER);
 937                         rc = ext4_fread(&fd, read_buffer, d, &rb);
 938
 939                         if (rc != EOK)
 940                                 break;
 941
 942                         if (rb != d) {
 943                                 printf("Read count error\n");
 944                                 return -1;
 945                         }
 946
 947                         if (memcmp(read_buffer, write_buffer, d)) {
 948                                 printf("Read compare error\n");
 949                                 return -1;
 950                         }
 951
 952                         len -= d;
 953                 }
 954         }
 955
 956         return rc;
 957 }
 958
 959 int _multi_fremove(char *p)
 960 {
 961         char path[256];
 962         char path1[256];
 963         char prefix[32];
 964         int cnt, i, rc;
 965
 966         if (sscanf(p, "%s %s %d", path, prefix, &cnt) != 3) {
 967                 printf("Param list error\n");
 968                 return -1;
 969         }
 970
 971         for (i = 0; i < cnt; ++i) {
 972                 sprintf(path1, "%s%s%d", path, prefix, i);
 973                 rc = ext4_fremove(path1);
 974                 if (rc != EOK)
 975                         break;
 976         }
 977
 978         return rc;
 979 }
 980
 981 int _multi_dcreate(char *p)
 982 {
 983         char path[256];
 984         char path1[256];
 985         char prefix[32];
 986         int cnt, i, rc;
 987
 988         if (sscanf(p, "%s %s %d", path, prefix, &cnt) != 3) {
 989                 printf("Param list error\n");
 990                 return -1;
 991         }
 992
 993         for (i = 0; i < cnt; ++i) {
 994                 sprintf(path1, "%s%s%d", path, prefix, i);
 995                 rc = ext4_dir_mk(path1);
 996                 if (rc != EOK)
 997                         break;
 998         }
 999
1000         return rc;
1001 }
1002
1003 int _multi_dremove(char *p)
1004 {
1005         char path[256];
1006         char path1[256];
1007         char prefix[32];
1008         int cnt, i, rc;
1009
1010         if (sscanf(p, "%s %s %d", path, prefix, &cnt) != 3) {
1011                 printf("Param list error\n");
1012                 return -1;
1013         }
1014
1015         for (i = 0; i < cnt; ++i) {
1016                 sprintf(path1, "%s%s%d", path, prefix, i);
1017                 rc = ext4_dir_rm(path1);
1018                 if (rc != EOK)
1019                         break;
1020         }
1021
1022         return rc;
1023 }
1024
1025 struct ext4_mount_stats saved_stats;
1026
1027 int _stats_save(char *p)
1028 {
1029         char path[256];
1030
1031         if (sscanf(p, "%s", path) != 1) {
1032                 printf("Param list error\n");
1033                 return -1;
1034         }
1035
1036         return ext4_mount_point_stats(path, &saved_stats);
1037 }
1038
1039 int _stats_check(char *p)
1040 {
1041         char path[256];
1042         int rc;
1043
1044         struct ext4_mount_stats actual_stats;
1045
1046         if (sscanf(p, "%s", path) != 1) {
1047                 printf("Param list error\n");
1048                 return -1;
1049         }
1050
1051         rc = ext4_mount_point_stats(path, &actual_stats);
1052
1053         if (rc != EOK)
1054                 return rc;
1055
1056         if (memcmp(&saved_stats, &actual_stats,
1057                    sizeof(struct ext4_mount_stats))) {
1058                 if (verbose) {
1059                         printf("\tMount point stats error:\n");
1060                         printf("\tsaved_stats:\n");
1061                         printf("\tinodes_count = %d\n",
1062                                saved_stats.inodes_count);
1063                         printf("\tfree_inodes_count = %d\n",
1064                                saved_stats.free_inodes_count);
1065                         printf("\tblocks_count = %llu\n",
1066                                saved_stats.blocks_count);
1067                         printf("\tfree_blocks_count = %llu\n",
1068                                saved_stats.free_blocks_count);
1069                         printf("\tblock_size = %d\n", saved_stats.block_size);
1070                         printf("\tblock_group_count = %d\n",
1071                                saved_stats.block_group_count);
1072                         printf("\tblocks_per_group = %d\n",
1073                                saved_stats.blocks_per_group);
1074                         printf("\tinodes_per_group = %d\n",
1075                                saved_stats.inodes_per_group);
1076                         printf("\tvolume_name = %s\n", saved_stats.volume_name);
1077                         printf("\tactual_stats:\n");
1078                         printf("\tinodes_count = %d\n",
1079                                actual_stats.inodes_count);
1080                         printf("\tfree_inodes_count = %d\n",
1081                                actual_stats.free_inodes_count);
1082                         printf("\tblocks_count = %llu\n",
1083                                actual_stats.blocks_count);
1084                         printf("\tfree_blocks_count = %llu\n",
1085                                actual_stats.free_blocks_count);
1086                         printf("\tblock_size = %d\n", actual_stats.block_size);
1087                         printf("\tblock_group_count = %d\n",
1088                                actual_stats.block_group_count);
1089                         printf("\tblocks_per_group = %d\n",
1090                                actual_stats.blocks_per_group);
1091                         printf("\tinodes_per_group = %d\n",
1092                                actual_stats.inodes_per_group);
1093                         printf("\tvolume_name = %s\n",
1094                                actual_stats.volume_name);
1095                 }
1096                 return -1;
1097         }
1098
1099         return rc;
1100 }
1101
1102 static char *entry_to_str(uint8_t type)
1103 {
1104         switch (type) {
1105         case EXT4_DIRENTRY_UNKNOWN:
1106                 return "[UNK] ";
1107         case EXT4_DIRENTRY_REG_FILE:
1108                 return "[FIL] ";
1109         case EXT4_DIRENTRY_DIR:
1110                 return "[DIR] ";
1111         case EXT4_DIRENTRY_CHRDEV:
1112                 return "[CHA] ";
1113         case EXT4_DIRENTRY_BLKDEV:
1114                 return "[BLK] ";
1115         case EXT4_DIRENTRY_FIFO:
1116                 return "[FIF] ";
1117         case EXT4_DIRENTRY_SOCK:
1118                 return "[SOC] ";
1119         case EXT4_DIRENTRY_SYMLINK:
1120                 return "[SYM] ";
1121         default:
1122                 break;
1123         }
1124         return "[???]";
1125 }
1126
1127 static int winsock_init(void)
1128 {
1129 #if WIN32
1130         int rc;
1131         static WSADATA wsaData;
1132         rc = WSAStartup(MAKEWORD(2, 2), &wsaData);
1133         if (rc != 0) {
1134                 return -1;
1135         }
1136 #endif
1137         return 0;
1138 }
1139
1140 static void winsock_fini(void)
1141 {
1142 #if WIN32
1143         WSACleanup();
1144 #endif
1145 }