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 v0.5 main master release
List of commits:
Subject Hash Author Date (UTC)
Lots of improvements 4953574e14ffba41e05e897fb94771f0ac7bab44 Catalin(ux) M. BOIE 2020-11-15 16:46:04
Allow verbose debug cee91423dda669c580b84451d3b846b3e7ef3038 Catalin(ux) M. BOIE 2020-11-15 12:11:04
Small bug caused by an old way to pack path ad3501ea5b7b112f0760f5aca247275e974edaff Catalin(ux) M. BOIE 2020-11-15 11:59:55
Lots of improvements 9275d4bc7be78518ac7bd2c3aa9cfb946a2969ad Catalin(ux) M. BOIE 2020-11-15 10:40:44
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 4953574e14ffba41e05e897fb94771f0ac7bab44 - Lots of improvements
Author: Catalin(ux) M. BOIE
Author date (UTC): 2020-11-15 16:46
Committer name: Catalin(ux) M. BOIE
Committer date (UTC): 2020-11-15 16:46
Parent(s): cee91423dda669c580b84451d3b846b3e7ef3038
Signer:
Signing key:
Signing status: N
Tree: c61d2e5c12e0d584db2cf9390d8f2ad7b7034d37
File Lines added Lines deleted
rgfs.c 30 35
File rgfs.c changed (mode: 100644) (index 6a370d8..a34764c)
... ... static void xlog(char *format, ...)
43 43 { {
44 44 va_list ap; va_list ap;
45 45 size_t len, len2; size_t len, len2;
46 char line[4096];
46 char line[4 * 4096];
47 47 struct timeval tv; struct timeval tv;
48 48
49 49 if (rgfs_debug == 0) if (rgfs_debug == 0)
 
... ... static ssize_t rgfs_recv(void *buf, const size_t buf_max)
87 87 /* /*
88 88 * Sending data * Sending data
89 89 */ */
90 static ssize_t rgfs_send(const void *buf, size_t buf_len)
90 static ssize_t rgfs_send(const char *op, const void *buf, size_t buf_len)
91 91 { {
92 92 ssize_t r; ssize_t r;
93 93
 
... ... static ssize_t rgfs_send(const void *buf, size_t buf_len)
96 96 short max = buf_len > 4096 ? 4096 : buf_len; short max = buf_len > 4096 ? 4096 : buf_len;
97 97 for (unsigned int i = 0; i < max; i++) for (unsigned int i = 0; i < max; i++)
98 98 sprintf(debug + i * 2, "%02hhx", * (unsigned char *) (buf + i)); sprintf(debug + i * 2, "%02hhx", * (unsigned char *) (buf + i));
99 xlog(" SEND %u: %s\n", buf_len, debug);
99 xlog(" %s: SEND %u: %s\n", op, buf_len, debug);
100 100 } }
101 101
102 102 do { do {
 
... ... static ssize_t rgfs_ws1(void)
182 182 rgfs_url, rgfs_server, rgfs_port); rgfs_url, rgfs_server, rgfs_port);
183 183
184 184 xlog("Sending:\n%s", out); xlog("Sending:\n%s", out);
185 return rgfs_send(out, len);
185 return rgfs_send("ws req", out, len);
186 186 } }
187 187
188 188 /* /*
 
... ... static int rgfs_tls(void)
299 299 buf[1] = 0; // len H buf[1] = 0; // len H
300 300 buf[2] = 1; // len L buf[2] = 1; // len L
301 301 buf[3] = RGFS_PROTOCOL_VERSION; buf[3] = RGFS_PROTOCOL_VERSION;
302 r = rgfs_send(buf, 4);
302 r = rgfs_send("send ver", buf, 4);
303 303 if (r <= 0) if (r <= 0)
304 304 break; break;
305 305
 
... ... static int rgfs_tls(void)
315 315 buf[1] = len >> 8; // len H buf[1] = len >> 8; // len H
316 316 buf[2] = len; // len L buf[2] = len; // len L
317 317 memcpy(buf + 3, rgfs_name, len); memcpy(buf + 3, rgfs_name, len);
318 r = rgfs_send(buf, 3 + len);
318 r = rgfs_send("name", buf, 3 + len);
319 319 if (r <= 0) if (r <= 0)
320 320 break; break;
321 321
 
... ... static int rgfs_tls(void)
329 329 buf[5] = rgfs_pkg_repo_id >> 8; buf[5] = rgfs_pkg_repo_id >> 8;
330 330 buf[6] = rgfs_pkg_repo_id; buf[6] = rgfs_pkg_repo_id;
331 331 memcpy(buf + 7, rgfs_key, len); memcpy(buf + 7, rgfs_key, len);
332 r = rgfs_send(buf, 7 + len);
332 r = rgfs_send("repo&key", buf, 7 + len);
333 333 if (r <= 0) if (r <= 0)
334 334 break; break;
335 335
 
... ... static void rgfs_reconnect(void)
357 357 xlog("Reconnecting...\n"); xlog("Reconnecting...\n");
358 358 r = rgfs_tls(); r = rgfs_tls();
359 359 if (r == 0) { if (r == 0) {
360 xlog("Reconnecting OK!\n");
360 xlog(" Reconnecting OK!\n");
361 361 connected = 1; connected = 1;
362 362 break; break;
363 363 } }
364 364 if (r == 1) { if (r == 1) {
365 xlog("Exiting!");
365 xlog(" Exiting!");
366 366 exit(1); exit(1);
367 367 } }
368 368
369 xlog("Sleeping...\n");
369 xlog(" Sleeping...\n");
370 370 sleep(1); sleep(1);
371 371 } }
372 372 } }
373 373
374 static int rgfs_recv_hl(void *buf, size_t buf_size)
374 static int rgfs_recv_hl(const char *op, void *buf, size_t buf_size)
375 375 { {
376 376 int r; int r;
377 377 uint32_t off, to_read = 0; uint32_t off, to_read = 0;
 
... ... static int rgfs_recv_hl(void *buf, size_t buf_size)
396 396 short max = off > 4096 ? 4096 : off; short max = off > 4096 ? 4096 : off;
397 397 for (unsigned int i = 0; i < max; i++) for (unsigned int i = 0; i < max; i++)
398 398 sprintf(debug + i * 2, "%02hhx", * (unsigned char *) (buf + i)); sprintf(debug + i * 2, "%02hhx", * (unsigned char *) (buf + i));
399 xlog(" RECV %u: %s\n", off, debug);
399 xlog(" %s: RECV %u: %s\n", op, off, debug);
400 400 } }
401 401
402 402 if (off == 4 + to_read) { if (off == 4 + to_read) {
 
... ... static int rgfs_recv_hl(void *buf, size_t buf_size)
406 406 } }
407 407 } }
408 408
409 static ssize_t rgfs_send_recv(const void *out_buf, size_t out_buf_len,
409 static ssize_t rgfs_send_recv(const char *op,
410 const void *out_buf, size_t out_buf_len,
410 411 void *in_buf, size_t in_buf_size) void *in_buf, size_t in_buf_size)
411 412 { {
412 413 int r; int r;
 
... ... static ssize_t rgfs_send_recv(const void *out_buf, size_t out_buf_len,
416 417
417 418 while (1) { while (1) {
418 419 //xlog(" Sending %zu bytes\n", out_buf_len); //xlog(" Sending %zu bytes\n", out_buf_len);
419 r = rgfs_send(out_buf, out_buf_len);
420 r = rgfs_send(op, out_buf, out_buf_len);
420 421 if (r <= 0) { if (r <= 0) {
421 422 rgfs_reconnect(); rgfs_reconnect();
422 423 continue; continue;
423 424 } }
424 425
425 r = rgfs_recv_hl(in_buf, in_buf_size);
426 r = rgfs_recv_hl(op, in_buf, in_buf_size);
426 427 if (r <= 0) { if (r <= 0) {
427 428 rgfs_reconnect(); rgfs_reconnect();
428 429 continue; continue;
 
... ... static int rgfs_fuse_getattr(const char *path, struct stat *s)
455 456 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
456 457 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
457 458 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
458 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
459 r = rgfs_send_recv("getattr", buf, i, buf, sizeof(buf));
459 460
460 461 memset(s, 0, sizeof(struct stat)); memset(s, 0, sizeof(struct stat));
461 462 i = 4; i = 4;
 
... ... static int rgfs_fuse_readdir(const char *dir, void *out,
509 510 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
510 511 u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8;
511 512 memcpy(buf + i, dir, path_len); i += path_len; memcpy(buf + i, dir, path_len); i += path_len;
512 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
513 r = rgfs_send_recv("readdir", buf, i, buf, sizeof(buf));
513 514
514 515 // standard // standard
515 516 filler(out, ".", NULL, 0); filler(out, ".", NULL, 0);
 
... ... static int rgfs_fuse_read(const char *path, char *out, size_t size,
588 589 u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8;
589 590 u64 = htobe64(size); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(size); memcpy(buf + i, &u64, 8); i += 8;
590 591 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
591 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
592 r = rgfs_send_recv("read", buf, i, buf, sizeof(buf));
592 593
593 594 i = 4; i = 4;
594 595 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_write(const char *path, const char *in, size_t size,
623 624 (void) fi; (void) fi;
624 625
625 626 xlog("write: path=%s size=%zu offset=%zd\n", path, size, offset); xlog("write: path=%s size=%zu offset=%zd\n", path, size, offset);
626 #if 0
627 for (unsigned int j = 0; j < 32; j++)
628 xlog("%02hhx", in[j]);
629 xlog("\n");
630 #endif
631 627
632 628 path_len = strlen(path); path_len = strlen(path);
633 629 len = 1 + 2 + 2 + 8 + path_len + size; len = 1 + 2 + 2 + 8 + path_len + size;
 
... ... static int rgfs_fuse_write(const char *path, const char *in, size_t size,
644 640 u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(offset); memcpy(buf + i, &u64, 8); i += 8;
645 641 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
646 642 memcpy(buf + i, in, size); i += size; memcpy(buf + i, in, size); i += size;
647 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
643 r = rgfs_send_recv("write", buf, i, buf, sizeof(buf));
648 644
649 645 i = 4; i = 4;
650 646 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_create(const char *path, mode_t mode,
692 688 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
693 689 u32 = htobe32(mode); memcpy(buf + i, &u32, 4); i += 4; u32 = htobe32(mode); memcpy(buf + i, &u32, 4); i += 4;
694 690 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
695 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
691 r = rgfs_send_recv("create", buf, i, buf, sizeof(buf));
696 692
697 693 i = 4; i = 4;
698 694 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_mkdir(const char *path, mode_t mode)
732 728 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
733 729 u32 = htobe32(mode); memcpy(buf + i, &u32, 4); i += 4; u32 = htobe32(mode); memcpy(buf + i, &u32, 4); i += 4;
734 730 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
735 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
731 r = rgfs_send_recv("mkdir", buf, i, buf, sizeof(buf));
736 732
737 733 i = 4; i = 4;
738 734 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_unlink(const char *path)
770 766 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
771 767 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
772 768 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
773 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
769 r = rgfs_send_recv("unlink", buf, i, buf, sizeof(buf));
774 770
775 771 i = 4; i = 4;
776 772 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_rmdir(const char *path)
808 804 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
809 805 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
810 806 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
811 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
807 r = rgfs_send_recv("rmdir", buf, i, buf, sizeof(buf));
812 808
813 809 i = 4; i = 4;
814 810 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_rename(const char *old, const char *new)
850 846 u16 = htobe16(new_len); memcpy(buf + i, &u16, 2); i += 2; u16 = htobe16(new_len); memcpy(buf + i, &u16, 2); i += 2;
851 847 memcpy(buf + i, old, old_len); i += old_len; memcpy(buf + i, old, old_len); i += old_len;
852 848 memcpy(buf + i, new, new_len); i += new_len; memcpy(buf + i, new, new_len); i += new_len;
853 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
849 r = rgfs_send_recv("rename", buf, i, buf, sizeof(buf));
854 850
855 851 i = 4; i = 4;
856 852 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_truncate(const char *path, off_t off)
890 886 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
891 887 u64 = htobe64(off); memcpy(buf + i, &u64, 8); i += 8; u64 = htobe64(off); memcpy(buf + i, &u64, 8); i += 8;
892 888 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
893 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
889 r = rgfs_send_recv("truncate", buf, i, buf, sizeof(buf));
894 890
895 891 i = 4; i = 4;
896 892 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_utimens(const char *path, const struct timespec tv[2])
935 931 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;
936 932 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;
937 933 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
938 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
934 r = rgfs_send_recv("utimens", buf, i, buf, sizeof(buf));
939 935
940 936 i = 4; i = 4;
941 937 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_readlink(const char *path, char *out, size_t out_size)
974 970 buf[i++] = (len - 1 - 2) >> 8; buf[i++] = (len - 1 - 2) >> 8;
975 971 buf[i++] = len - 1 - 2; buf[i++] = len - 1 - 2;
976 972 memcpy(buf + i, path, path_len); i += path_len; memcpy(buf + i, path, path_len); i += path_len;
977 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
973 r = rgfs_send_recv("readlink", buf, i, buf, sizeof(buf));
978 974
979 // 00000022 01 0006626c613132330100026f73010009726f6f745f6161615f010001780100
980 975 i = 4; i = 4;
981 976 if (i < r) { if (i < r) {
982 977 cmd = buf[i++]; cmd = buf[i++];
 
... ... static int rgfs_fuse_symlink(const char *target, const char *link)
1027 1022 u16 = htobe16(link_len); memcpy(buf + i, &u16, 2); i += 2; u16 = htobe16(link_len); memcpy(buf + i, &u16, 2); i += 2;
1028 1023 memcpy(buf + i, target, target_len); i += target_len; memcpy(buf + i, target, target_len); i += target_len;
1029 1024 memcpy(buf + i, link, link_len); i += link_len; memcpy(buf + i, link, link_len); i += link_len;
1030 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
1025 r = rgfs_send_recv("symlink", buf, i, buf, sizeof(buf));
1031 1026
1032 1027 i = 4; i = 4;
1033 1028 if (i < r) { if (i < r) {
 
... ... static int rgfs_fuse_link(const char *target, const char *link)
1069 1064 u16 = htobe16(link_len); memcpy(buf + i, &u16, 2); i += 2; u16 = htobe16(link_len); memcpy(buf + i, &u16, 2); i += 2;
1070 1065 memcpy(buf + i, target, target_len); i += target_len; memcpy(buf + i, target, target_len); i += target_len;
1071 1066 memcpy(buf + i, link, link_len); i += link_len; memcpy(buf + i, link, link_len); i += link_len;
1072 r = rgfs_send_recv(buf, i, buf, sizeof(buf));
1067 r = rgfs_send_recv("link", buf, i, buf, sizeof(buf));
1073 1068
1074 1069 i = 4; i = 4;
1075 1070 if (i < r) { if (i < r) {
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