catalinux / rgfs (public) (License: GPLv3) (since 2020-11-11) (hash sha1)
Allows mapping of RocketGit storage area into a local directory
Clone URLs: https://rocketgit.com/user/catalinux/rgfs ssh://rocketgit@ssh.rocketgit.com/user/catalinux/rgfs git://git.rocketgit.com/user/catalinux/rgfs
0.4 v0.0 v0.1 v0.2 v0.4 main master release
List of commits:
Subject Hash Author Date (UTC)
Lots of cleanups 2998ff2dcb74565887986fb7167e65e4fdf6d173 Catalin(ux) M. BOIE 2020-11-14 19:23:09
added utimens b5c24acf3ff86a51a7a49fec1eaf8eb65ae77bbb Catalin(ux) M. BOIE 2020-11-14 16:09:29
Improved debug f9bdf71667d0c77d4fcb4fa6e7792fd2d4c60712 Catalin(ux) M. BOIE 2020-11-13 18:57:48
Allow pushing a name and a repo id 9b48c3ae2a059a1ecd84caf44cea6c551175dd46 Catalin(ux) M. BOIE 2020-11-12 16:14:02
Send also the pkg_repo_id parameter 866c8063866effdabe0aa76fcfb9cc2b3d61b67a Catalin(ux) M. BOIE 2020-11-12 07:54:07
Now we can pass parameters by env 8352d8d09714a3c2af7550ad55517bfa8590a309 Catalin(ux) M. BOIE 2020-11-12 04:48:19
Inistial commit e51779259596117c80f6e7961f4387fdd48f820a Catalin(ux) M. BOIE 2020-11-11 08:18:38
Commit 2998ff2dcb74565887986fb7167e65e4fdf6d173 - Lots of cleanups
Author: Catalin(ux) M. BOIE
Author date (UTC): 2020-11-14 19:23
Committer name: Catalin(ux) M. BOIE
Committer date (UTC): 2020-11-14 19:23
Parent(s): b5c24acf3ff86a51a7a49fec1eaf8eb65ae77bbb
Signing key:
Tree: 18889c93e01602f62cd69d7fda624422d973613f
File Lines added Lines deleted
rgfs.c 125 137
File rgfs.c changed (mode: 100644) (index 1162fea..fc94f54)
... ... static int rgfs_fuse_readdir(const char *dir, void *out,
484 484 char path[512]; char path[512];
485 485 uint64_t u64; uint64_t u64;
486 486
487 (void) offset;
488 487 (void) fi; (void) fi;
489 488 xlog("readdir: dir=%s offset=%zd\n", dir, offset); xlog("readdir: dir=%s offset=%zd\n", dir, offset);
490 489
 
... ... static int rgfs_fuse_open(const char *path, struct fuse_file_info *fi)
551 550 return 0; return 0;
552 551 } }
553 552
554 static int rgfs_fuse_create(const char *path, mode_t mode,
555 struct fuse_file_info *fi)
553 static int rgfs_fuse_read(const char *path, char *out, size_t size,
554 off_t offset, struct fuse_file_info *fi)
556 555 { {
557 int err = 0, r, i;
558 uint16_t u16, path_len, len;
559 unsigned char buf[4 * 4096], cmd;
556 int r, err = 0, i;
557 unsigned char buf[16 * 4096], cmd;
558 uint16_t path_len, len;
559 uint64_t u64;
560 560
561 (void) mode;
562 561 (void) fi; (void) fi;
563 xlog("create: path=%s\n", path);
562 xlog("read: path=%s size=%zu offset=%zd\n",
563 path, size, offset);
564
565 // Limit how much data we request to the server
566 // 1 + 4 + 8 is the answer's header.
567 if (size > sizeof(buf) - 1 - 4)
568 size = sizeof(buf) - 1 - 4;
564 569
565 570 path_len = strlen(path); path_len = strlen(path);
566 len = 1 + 2 + 2 + path_len;
571 len = 1 + 2 + 8 + 8 + path_len;
567 572 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
568 573 xlog(" buffer too small\n"); xlog(" buffer too small\n");
569 574 return -EIO; return -EIO;
570 575 } }
571 576
572 577 i = 0; i = 0;
573 buf[i++] = 0x06;
578 buf[i++] = 0x04;
574 579 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
575 580 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
576 u16 = htobe16(path_len); memcpy(buf + i, &u16, 2); i += 2;
581 u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8;
582 u64 = htobe64(size); memcpy(buf + i, &u64, 8); i += 8;
577 583 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
578 584 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
579 585
580 586 i = 4; i = 4;
581 while (i < r) {
587 if (i < r) {
582 588 cmd = buf[i++]; cmd = buf[i++];
583 589 //xlog(" cmd=0x%02hhx\n", cmd); //xlog(" cmd=0x%02hhx\n", cmd);
584 590 switch (cmd) { switch (cmd) {
585 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
591 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
592 case 0x01: /* block */
593 xlog(" received %llu bytes block\n", r - i);
594 memcpy(out, buf + i, r - i);
595 break;
586 596 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
587 597 } }
588 598 } }
 
... ... static int rgfs_fuse_create(const char *path, mode_t mode,
592 602 return err; return err;
593 603 } }
594 604
595 return 0;
605 return r - i;
596 606 } }
597 607
598 static int rgfs_fuse_mkdir(const char *path, mode_t mode)
608 static int rgfs_fuse_write(const char *path, const char *in, size_t size,
609 off_t offset, struct fuse_file_info *fi)
599 610 { {
600 int err = 0, r, i;
601 uint16_t u16, path_len, len;
611 int r, err = 0, i;
602 612 unsigned char buf[4 * 4096], cmd; unsigned char buf[4 * 4096], cmd;
613 uint16_t path_len, len;
614 uint64_t u64;
615
616 (void) fi;
603 617
604 (void) mode;
605 xlog("mkdir: path=%s\n", path);
618 xlog("write: path=%s size=%zu offset=%zd\n", path, size, offset);
619 #if 0
620 for (unsigned int j = 0; j < 32; j++)
621 xlog("%02hhx", in[j]);
622 xlog("\n");
623 #endif
606 624
607 625 path_len = strlen(path); path_len = strlen(path);
608 len = 1 + 2 + 2 + path_len;
626 len = 1 + 2 + 8 + path_len + 1 + size;
609 627 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
610 628 xlog(" buffer too small\n"); xlog(" buffer too small\n");
611 629 return -EIO; return -EIO;
612 630 } }
613 631
614 632 i = 0; i = 0;
615 buf[i++] = 0x07;
616 buf[i++] = (2 + path_len) / 256;
617 buf[i++] = 2 + path_len;
618 u16 = htobe16(path_len); memcpy(buf + i, &u16, 2); i += 2;
619 memcpy(buf + i, path, path_len); i += path_len;
633 buf[i++] = 0x05;
634 buf[i++] = (len - 1 - 2) >> 8;
635 buf[i++] = len - 1 - 2;
636 u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8;
637 memcpy(buf + i, path, path_len); buf[i] = '\0'; i += path_len + 1;
638 memcpy(buf + i, in, size); i += size;
620 639 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
621 640
622 641 i = 4; i = 4;
623 while (i < r) {
642 if (i < r) {
624 643 cmd = buf[i++]; cmd = buf[i++];
625 644 //xlog(" cmd=0x%02hhx\n", cmd); //xlog(" cmd=0x%02hhx\n", cmd);
626 645 switch (cmd) { switch (cmd) {
627 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
646 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
647 case 0x01: /* block */
648 u64 = be64toh(*(uint64_t *) (buf + i));
649 if (u64 != size)
650 xlog(" wrote only %llu bytes\n", u64);
651 break;
628 652 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
629 653 } }
630 654 } }
 
... ... static int rgfs_fuse_mkdir(const char *path, mode_t mode)
634 658 return err; return err;
635 659 } }
636 660
637 return 0;
661 return u64;
638 662 } }
639 663
640 static int rgfs_fuse_unlink(const char *path)
664 static int rgfs_fuse_create(const char *path, mode_t mode,
665 struct fuse_file_info *fi)
641 666 { {
642 667 int err = 0, r, i; int err = 0, r, i;
643 uint16_t u16, path_len, len;
668 uint16_t path_len, len;
644 669 unsigned char buf[4 * 4096], cmd; unsigned char buf[4 * 4096], cmd;
670 uint32_t u32;
645 671
646 xlog("unlink: path=%s\n", path);
672 (void) fi;
673 xlog("create: path=%s mode=%u\n", path, mode);
647 674
648 675 path_len = strlen(path); path_len = strlen(path);
649 len = 1 + 2 + 2 + path_len;
676 len = 1 + 2 + 4 + path_len;
650 677 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
651 678 xlog(" buffer too small\n"); xlog(" buffer too small\n");
652 679 return -EIO; return -EIO;
653 680 } }
654 681
655 682 i = 0; i = 0;
656 buf[i++] = 0x08;
683 buf[i++] = 0x06;
657 684 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
658 685 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
659 u16 = htobe16(path_len); memcpy(buf + i, &u16, 2); i += 2;
686 u32 = htobe16(mode); memcpy(buf + i, &u32, 4); i += 4;
660 687 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
661 688 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
662 689
663 690 i = 4; i = 4;
664 while (i < r) {
691 if (i < r) {
665 692 cmd = buf[i++]; cmd = buf[i++];
666 693 //xlog(" cmd=0x%02hhx\n", cmd); //xlog(" cmd=0x%02hhx\n", cmd);
667 694 switch (cmd) { switch (cmd) {
668 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
695 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
669 696 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
670 697 } }
671 698 } }
 
... ... static int rgfs_fuse_unlink(const char *path)
678 705 return 0; return 0;
679 706 } }
680 707
681 static int rgfs_fuse_rmdir(const char *path)
708 static int rgfs_fuse_mkdir(const char *path, mode_t mode)
682 709 { {
683 710 int err = 0, r, i; int err = 0, r, i;
684 uint16_t u16, path_len, len;
685 unsigned char buf[4096], cmd;
711 uint16_t path_len, len;
712 unsigned char buf[4 * 4096], cmd;
713 uint32_t u32;
686 714
687 xlog("rmdir: path=%s\n", path);
715 xlog("mkdir: path=%s mode=%u\n", path, mode);
688 716
689 717 path_len = strlen(path); path_len = strlen(path);
690 len = 1 + 2 + 2 + path_len;
718 len = 1 + 2 + 4 + path_len;
691 719 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
692 720 xlog(" buffer too small\n"); xlog(" buffer too small\n");
693 721 return -EIO; return -EIO;
694 722 } }
695 723
696 724 i = 0; i = 0;
697 buf[i++] = 0x09;
725 buf[i++] = 0x07;
698 726 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
699 727 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
700 u16 = htobe16(path_len); memcpy(buf + i, &u16, 2); i += 2;
728 u32 = htobe16(mode); memcpy(buf + i, &u32, 4); i += 4;
701 729 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
702 730 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
703 731
704 732 i = 4; i = 4;
705 while (i < r) {
733 if (i < r) {
706 734 cmd = buf[i++]; cmd = buf[i++];
707 735 //xlog(" cmd=0x%02hhx\n", cmd); //xlog(" cmd=0x%02hhx\n", cmd);
708 736 switch (cmd) { switch (cmd) {
709 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
737 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
710 738 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
711 739 } }
712 740 } }
 
... ... static int rgfs_fuse_rmdir(const char *path)
719 747 return 0; return 0;
720 748 } }
721 749
722 static int rgfs_fuse_truncate(const char *path, off_t off)
750 static int rgfs_fuse_unlink(const char *path)
723 751 { {
724 752 int err = 0, r, i; int err = 0, r, i;
725 uint16_t u16, path_len, len;
726 uint64_t u64;
727 unsigned char buf[4096], cmd;
753 uint16_t path_len, len;
754 unsigned char buf[4 * 4096], cmd;
728 755
729 xlog("truncate: path=%s off=%ld\n", path, off);
756 xlog("unlink: path=%s\n", path);
730 757
731 758 path_len = strlen(path); path_len = strlen(path);
732 len = 1 + 2 + 2 + 8 + path_len;
759 len = 1 + 2 + path_len;
733 760 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
734 761 xlog(" buffer too small\n"); xlog(" buffer too small\n");
735 762 return -EIO; return -EIO;
736 763 } }
737 764
738 765 i = 0; i = 0;
739 buf[i++] = 0x0b;
766 buf[i++] = 0x08;
740 767 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
741 768 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
742 u16 = htobe16(path_len); memcpy(buf + i, &u16, 2); i += 2;
743 u64 = htobe64(off); memcpy(buf + i, &u64, 8); i += 8;
744 769 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
745 770 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
746 771
747 772 i = 4; i = 4;
748 while (i < r) {
773 if (i < r) {
749 774 cmd = buf[i++]; cmd = buf[i++];
750 xlog(" cmd=0x%02hhx\n", cmd);
775 //xlog(" cmd=0x%02hhx\n", cmd);
751 776 switch (cmd) { switch (cmd) {
752 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
777 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
753 778 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
754 779 } }
755 780 } }
 
... ... static int rgfs_fuse_truncate(const char *path, off_t off)
762 787 return 0; return 0;
763 788 } }
764 789
765 static int rgfs_fuse_read(const char *path, char *out, size_t size,
766 off_t offset, struct fuse_file_info *fi)
790 static int rgfs_fuse_rmdir(const char *path)
767 791 { {
768 int r, err = 0, i;
769 unsigned char buf[16 * 4096], cmd;
792 int err = 0, r, i;
770 793 uint16_t path_len, len; uint16_t path_len, len;
771 uint64_t u64;
772
773 (void) fi;
774 xlog("read: path=%s size=%zu offset=%zd\n",
775 path, size, offset);
794 unsigned char buf[4096], cmd;
776 795
777 if (size > sizeof(buf) - 1 - 4 - 1 - 8)
778 size = sizeof(buf) - 1 - 4 - 1 - 8;
796 xlog("rmdir: path=%s\n", path);
779 797
780 798 path_len = strlen(path); path_len = strlen(path);
781 len = 1 + 2 + 8 + 8 + path_len;
799 len = 1 + 2 + path_len;
782 800 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
783 801 xlog(" buffer too small\n"); xlog(" buffer too small\n");
784 802 return -EIO; return -EIO;
785 803 } }
786 804
787 805 i = 0; i = 0;
788 buf[i++] = 0x04;
806 buf[i++] = 0x09;
789 807 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
790 808 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
791 u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8;
792 u64 = htobe64(size); memcpy(buf + i, &u64, 8); i += 8;
793 809 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
794 810 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
795 811
796 812 i = 4; i = 4;
797 while (i < r) {
813 if (i < r) {
798 814 cmd = buf[i++]; cmd = buf[i++];
799 815 //xlog(" cmd=0x%02hhx\n", cmd); //xlog(" cmd=0x%02hhx\n", cmd);
800 816 switch (cmd) { switch (cmd) {
801 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
802 case 0x01: /* block */
803 u64 = be64toh(*(uint64_t *) (buf + i)); i += 8;
804 xlog(" received %llu bytes block\n", u64);
805 if (i + u64 > (unsigned int) r) {
806 xlog(" packet error: i=%d + u64=%llu > r=%d\n",
807 i, u64, r);
808 return -EIO;
809 }
810 memcpy(out, buf + i, u64); i += u64;
811 break;
817 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
812 818 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
813 819 } }
814 820 } }
 
... ... static int rgfs_fuse_read(const char *path, char *out, size_t size,
818 824 return err; return err;
819 825 } }
820 826
821 return u64;
827 return 0;
822 828 } }
823 829
824 static int rgfs_fuse_write(const char *path, const char *in, size_t size,
825 off_t offset, struct fuse_file_info *fi)
830 static int rgfs_fuse_rename(const char *old, const char *new)
826 831 { {
827 832 int r, err = 0, i; int r, err = 0, i;
828 833 unsigned char buf[4 * 4096], cmd; unsigned char buf[4 * 4096], cmd;
829 uint16_t u16, path_len, len;
830 uint64_t u64;
834 uint16_t old_len, new_len, len;
831 835
832 (void) fi;
833
834 xlog("write: path=%s size=%zu offset=%zd\n", path, size, offset);
835 #if 0
836 for (unsigned int j = 0; j < 32; j++)
837 xlog("%02hhx", in[j]);
838 xlog("\n");
839 #endif
836 xlog("rename: old=%s new=%s\n", old, new);
840 837
841 path_len = strlen(path);
842 len = 1 + 2 + 2 + 8 + path_len + size;
838 old_len = strlen(old);
839 new_len = strlen(new);
840 len = 1 + 2 + old_len + 1 + new_len + 1;
843 841 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
844 842 xlog(" buffer too small\n"); xlog(" buffer too small\n");
845 843 return -EIO; return -EIO;
846 844 } }
847 845
848 846 i = 0; i = 0;
849 buf[i++] = 0x05;
847 buf[i++] = 0x0a;
850 848 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
851 849 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
852 u16 = htobe16(path_len); memcpy(buf + i, &u16, 2); i += 2;
853 u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8;
854 memcpy(buf + i, path, path_len); i += path_len;
855 memcpy(buf + i, in, size); i += size;
850 memcpy(buf + i, old, old_len); buf[i] = '\0'; i += old_len + 1;
851 memcpy(buf + i, new, new_len); buf[i] = '\0'; i += new_len + 1;
856 852 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
857 853
858 854 i = 4; i = 4;
859 while (i < r) {
855 if (i < r) {
860 856 cmd = buf[i++]; cmd = buf[i++];
861 857 //xlog(" cmd=0x%02hhx\n", cmd); //xlog(" cmd=0x%02hhx\n", cmd);
862 858 switch (cmd) { switch (cmd) {
863 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
864 case 0x01: /* block */
865 u64 = be64toh(*(uint64_t *) (buf + i)); i += 8;
866 if (u64 != size)
867 xlog(" wrote only %llu bytes\n", u64);
868 break;
859 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
869 860 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
870 861 } }
871 862 } }
 
... ... static int rgfs_fuse_write(const char *path, const char *in, size_t size,
875 866 return err; return err;
876 867 } }
877 868
878 return u64;
869 return 0;
879 870 } }
880 871
881 static int rgfs_fuse_rename(const char *old, const char *new)
872 static int rgfs_fuse_truncate(const char *path, off_t off)
882 873 { {
883 int r, err = 0, i;
884 unsigned char buf[4 * 4096], cmd;
885 uint16_t u16, old_len, new_len, len;
874 int err = 0, r, i;
875 uint16_t path_len, len;
876 uint64_t u64;
877 unsigned char buf[4096], cmd;
886 878
887 xlog("rename: old=%s new=%s\n", old, new);
879 xlog("truncate: path=%s off=%ld\n", path, off);
888 880
889 old_len = strlen(old);
890 new_len = strlen(new);
891 len = 1 + 2 + 2 + 2 + old_len + new_len;
881 path_len = strlen(path);
882 len = 1 + 2 + 8 + path_len;
892 883 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
893 884 xlog(" buffer too small\n"); xlog(" buffer too small\n");
894 885 return -EIO; return -EIO;
895 886 } }
896 887
897 888 i = 0; i = 0;
898 buf[i++] = 0x0a;
889 buf[i++] = 0x0b;
899 890 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
900 891 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
901 u16 = htobe16(old_len); memcpy(buf + i, &u16, 2); i += 2;
902 u16 = htobe16(new_len); memcpy(buf + i, &u16, 2); i += 2;
903 memcpy(buf + i, old, old_len); i += old_len;
904 memcpy(buf + i, new, new_len); i += new_len;
892 u64 = htobe64(off); memcpy(buf + i, &u64, 8); i += 8;
893 memcpy(buf + i, path, path_len); i += path_len;
905 894 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
906 895
907 896 i = 4; i = 4;
908 while (i < r) {
897 if (i < r) {
909 898 cmd = buf[i++]; cmd = buf[i++];
910 //xlog(" cmd=0x%02hhx\n", cmd);
899 xlog(" cmd=0x%02hhx\n", cmd);
911 900 switch (cmd) { switch (cmd) {
912 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
901 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
913 902 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
914 903 } }
915 904 } }
 
... ... static int rgfs_fuse_utimens(const char *path, const struct timespec tv[2])
926 915 { {
927 916 int r, err = 0, i; int r, err = 0, i;
928 917 unsigned char buf[4 * 4096], cmd; unsigned char buf[4 * 4096], cmd;
929 uint16_t u16, len;
918 uint16_t len, path_len;
930 919 uint64_t u64; uint64_t u64;
931 920
932 // sizeof(time_t) = 8; sizeof(long) = 8
921 // sizeof(time_t) = 8; sizeof(long) = 8 tv[0]=atime, tv[1]=mtime
933 922 xlog("utimens: path=%s atime=%lu.%lu mtime=%lu.%lu\n", xlog("utimens: path=%s atime=%lu.%lu mtime=%lu.%lu\n",
934 923 path, tv[0].tv_sec, tv[0].tv_nsec, tv[1].tv_sec, tv[1].tv_nsec); path, tv[0].tv_sec, tv[0].tv_nsec, tv[1].tv_sec, tv[1].tv_nsec);
935 924
936 len = strlen(path);
937 len = 1 + 2 + 2 + len + 4 * 8;
925 path_len = strlen(path);
926 len = 1 + 2 + 4 * 8 + path_len;
938 927 if (len > sizeof(buf)) { if (len > sizeof(buf)) {
939 928 xlog(" buffer too small\n"); xlog(" buffer too small\n");
940 929 return -EIO; return -EIO;
941 930 } }
942 931
943 932 i = 0; i = 0;
944 buf[i++] = 0x0a;
933 buf[i++] = 0x0c;
945 934 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
946 935 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
947 u16 = htobe16(len); memcpy(buf + i, &u16, 2); i += 2;
948 memcpy(buf + i, path, len); i += len;
949 936 u64 = htobe64(tv[0].tv_sec); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(tv[0].tv_sec); memcpy(buf + i, &u64, 8); i += 8;
950 937 u64 = htobe64(tv[0].tv_nsec); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(tv[0].tv_nsec); memcpy(buf + i, &u64, 8); i += 8;
951 938 u64 = htobe64(tv[1].tv_sec); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(tv[1].tv_sec); memcpy(buf + i, &u64, 8); i += 8;
952 939 u64 = htobe64(tv[1].tv_nsec); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(tv[1].tv_nsec); memcpy(buf + i, &u64, 8); i += 8;
940 memcpy(buf + i, path, path_len); i += path_len;
953 941 r = rgfs_send_recv(buf, i, buf, sizeof(buf)); r = rgfs_send_recv(buf, i, buf, sizeof(buf));
954 942
955 943 i = 4; i = 4;
956 while (i < r) {
944 if (i < r) {
957 945 cmd = buf[i++]; cmd = buf[i++];
958 946 //xlog(" cmd=0x%02hhx\n", cmd); //xlog(" cmd=0x%02hhx\n", cmd);
959 947 switch (cmd) { switch (cmd) {
960 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); i += 4; break;
948 case 0x00: err = - be32toh(*(uint32_t *) (buf + i)); break;
961 949 default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE); default: xlog("Unexpected subcode 0x%02hhx!\n", cmd); exit(EXIT_FAILURE);
962 950 } }
963 951 } }
Hints:
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://rocketgit.com/user/catalinux/rgfs

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@ssh.rocketgit.com/user/catalinux/rgfs

Clone this repository using git:
git clone git://git.rocketgit.com/user/catalinux/rgfs

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
... clone the repository ...
... make some changes and some commits ...
git push origin main