/* * registry/sleela_registry.c -- Sleela Registry (C implementation). * * Idea System(TM) / Idea(TM). From Author; distributive. * * A bounded, deterministic key/value + provenance store. Keys are held in a * sorted array (so save/review are stable and idempotent). Each key owns a * small set of named values and, optionally, one provenance record carrying the * file identity + SHA-256 + originality seal. Pure C. */ #include "sleela_registry.h" #include #include #include #define SL_REG_MAX_KEYS 4096 #define SL_REG_MAX_VALUES 16 /* values per key */ #define SL_REG_PATH_CAP 256 #define SL_REG_NAME_CAP 64 #define SL_REG_STR_CAP 256 typedef struct { char name[SL_REG_NAME_CAP]; sl_reg_kind kind; char s[SL_REG_STR_CAP]; long i; int b; int used; } RegValue; typedef struct { char path[SL_REG_PATH_CAP]; RegValue values[SL_REG_MAX_VALUES]; int nvalues; int has_prov; sl_reg_provenance prov; int used; } RegKey; struct sl_registry { RegKey *keys; int nkeys; int cap; }; /* ---- SHA-256 (FIPS 180-4, self-contained) ----------------------------- */ static uint32_t rotr(uint32_t x, uint32_t n){ return (x>>n)|(x<<(32-n)); } void sl_reg_sha256_hex(const void *data, size_t len, char *out){ static const uint32_t K[64]={ 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5, 0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174, 0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da, 0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967, 0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85, 0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070, 0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3, 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2}; uint32_t h[8]={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19}; size_t padded=((len+8)/64+1)*64; unsigned char *m=(unsigned char*)calloc(1,padded); memcpy(m,data,len); m[len]=0x80; uint64_t bits=(uint64_t)len*8; for(int i=0;i<8;++i) m[padded-1-i]=(unsigned char)((bits>>(8*i))&0xff); for(size_t off=0;off>3); uint32_t s1=rotr(w[i-2],17)^rotr(w[i-2],19)^(w[i-2]>>10); w[i]=w[i-16]+s0+w[i-7]+s1; } uint32_t a=h[0],b=h[1],c=h[2],d=h[3],e=h[4],f=h[5],g=h[6],hh=h[7]; for(int i=0;i<64;++i){ uint32_t S1=rotr(e,6)^rotr(e,11)^rotr(e,25); uint32_t ch=(e&f)^((~e)&g); uint32_t t1=hh+S1+ch+K[i]+w[i]; uint32_t S0=rotr(a,2)^rotr(a,13)^rotr(a,22); uint32_t maj=(a&b)^(a&c)^(b&c); uint32_t t2=S0+maj; hh=g;g=f;f=e;e=d+t1;d=c;c=b;b=a;a=t1+t2; } h[0]+=a;h[1]+=b;h[2]+=c;h[3]+=d;h[4]+=e;h[5]+=f;h[6]+=g;h[7]+=hh; } free(m); static const char *hx="0123456789abcdef"; for(int i=0;i<8;++i) for(int j=7;j>=0;--j){ *out++=hx[(h[i]>>(j*4))&0xf]; } *out='\0'; } /* ---- seal ------------------------------------------------------------- */ void sl_reg_seal(sl_reg_provenance *p){ if(!p) return; char buf[17+64+65+128+8]; int n=snprintf(buf,sizeof buf,"%s|%s|%s|%s",p->hex_id,p->version,p->hash,p->author); if(n<0) n=0; sl_reg_sha256_hex(buf,(size_t)n,p->seal); } int sl_reg_seal_verify(const sl_reg_provenance *p){ if(!p) return 0; sl_reg_provenance tmp=*p; tmp.seal[0]='\0'; sl_reg_seal(&tmp); return strncmp(tmp.seal,p->seal,64)==0 ? 1 : 0; } /* ---- key store -------------------------------------------------------- */ sl_registry *sl_reg_create(void){ sl_registry *r=(sl_registry*)calloc(1,sizeof(*r)); if(!r) return NULL; r->cap=SL_REG_MAX_KEYS; r->keys=(RegKey*)calloc((size_t)r->cap,sizeof(RegKey)); if(!r->keys){ free(r); return NULL; } return r; } void sl_reg_destroy(sl_registry *r){ if(r){ free(r->keys); free(r); } } static RegKey *find_key(const sl_registry *r,const char *path){ for(int i=0;inkeys;++i) if(r->keys[i].used && strcmp(r->keys[i].path,path)==0) return (RegKey*)&r->keys[i]; return NULL; } static int key_cmp(const void*a,const void*b){ return strcmp(((const RegKey*)a)->path,((const RegKey*)b)->path); } static RegKey *ensure_key(sl_registry *r,const char *path){ RegKey *k=find_key(r,path); if(k) return k; if(r->nkeys>=r->cap) return NULL; k=&r->keys[r->nkeys++]; memset(k,0,sizeof(*k)); strncpy(k->path,path,SL_REG_PATH_CAP-1); k->used=1; qsort(r->keys,(size_t)r->nkeys,sizeof(RegKey),key_cmp); return find_key(r,path); } sl_reg_status sl_reg_key_create(sl_registry *r,const char *path){ if(!r||!path) return SL_REG_INVALID; /* make parents: A, A/B, A/B/C */ char buf[SL_REG_PATH_CAP]; strncpy(buf,path,sizeof buf-1); buf[sizeof buf-1]='\0'; char acc[SL_REG_PATH_CAP]=""; char *tok=strtok(buf,"/"); while(tok){ if(acc[0]) strncat(acc,"/",sizeof acc-strlen(acc)-1); strncat(acc,tok,sizeof acc-strlen(acc)-1); if(!ensure_key(r,acc)) return SL_REG_LIMIT; tok=strtok(NULL,"/"); } if(!path[0]) ensure_key(r,""); return SL_REG_OK; } int sl_reg_key_exists(const sl_registry *r,const char *path){ return (r&&path&&find_key(r,path))?1:0; } int sl_reg_key_children(const sl_registry *r,const char *path,char **names,int max,size_t name_cap){ if(!r||!path||!names) return 0; size_t plen=strlen(path); int count=0; for(int i=0;inkeys&&countkeys[i].path; if(!r->keys[i].used) continue; if(plen>0){ if(strncmp(kp,path,plen)!=0||kp[plen]!='/') continue; kp+=plen+1; } if(!*kp) continue; if(strchr(kp,'/')) continue; /* direct child only */ strncpy(names[count],kp,name_cap-1); names[count][name_cap-1]='\0'; count++; } return count; } /* ---- values ----------------------------------------------------------- */ static RegValue *find_val(RegKey *k,const char *name){ for(int i=0;invalues;++i) if(k->values[i].used&&strcmp(k->values[i].name,name)==0) return &k->values[i]; return NULL; } static RegValue *ensure_val(RegKey *k,const char *name){ RegValue *v=find_val(k,name); if(v) return v; if(k->nvalues>=SL_REG_MAX_VALUES) return NULL; v=&k->values[k->nvalues++]; memset(v,0,sizeof(*v)); strncpy(v->name,name,SL_REG_NAME_CAP-1); v->used=1; return v; } sl_reg_status sl_reg_set_string(sl_registry *r,const char *path,const char *name,const char *value){ if(!r||!path||!name||!value) return SL_REG_INVALID; sl_reg_key_create(r,path); RegKey *k=find_key(r,path); if(!k) return SL_REG_LIMIT; RegValue *v=ensure_val(k,name); if(!v) return SL_REG_LIMIT; v->kind=SL_REG_STRING; strncpy(v->s,value,SL_REG_STR_CAP-1); v->s[SL_REG_STR_CAP-1]='\0'; return SL_REG_OK; } sl_reg_status sl_reg_set_int(sl_registry *r,const char *path,const char *name,long value){ if(!r||!path||!name) return SL_REG_INVALID; sl_reg_key_create(r,path); RegKey *k=find_key(r,path); if(!k) return SL_REG_LIMIT; RegValue *v=ensure_val(k,name); if(!v) return SL_REG_LIMIT; v->kind=SL_REG_INT; v->i=value; return SL_REG_OK; } sl_reg_status sl_reg_set_bool(sl_registry *r,const char *path,const char *name,int value){ if(!r||!path||!name) return SL_REG_INVALID; sl_reg_key_create(r,path); RegKey *k=find_key(r,path); if(!k) return SL_REG_LIMIT; RegValue *v=ensure_val(k,name); if(!v) return SL_REG_LIMIT; v->kind=SL_REG_BOOL; v->b=value?1:0; return SL_REG_OK; } sl_reg_status sl_reg_get_string(const sl_registry *r,const char *path,const char *name,char *buf,size_t cap){ if(!r||!path||!name||!buf) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k) return SL_REG_NOT_FOUND; RegValue *v=find_val(k,name); if(!v) return SL_REG_NOT_FOUND; if(v->kind!=SL_REG_STRING) return SL_REG_INVALID; strncpy(buf,v->s,cap-1); buf[cap-1]='\0'; return SL_REG_OK; } sl_reg_status sl_reg_get_int(const sl_registry *r,const char *path,const char *name,long *out){ if(!r||!path||!name||!out) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k) return SL_REG_NOT_FOUND; RegValue *v=find_val(k,name); if(!v) return SL_REG_NOT_FOUND; if(v->kind!=SL_REG_INT) return SL_REG_INVALID; *out=v->i; return SL_REG_OK; } sl_reg_status sl_reg_get_bool(const sl_registry *r,const char *path,const char *name,int *out){ if(!r||!path||!name||!out) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k) return SL_REG_NOT_FOUND; RegValue *v=find_val(k,name); if(!v) return SL_REG_NOT_FOUND; if(v->kind!=SL_REG_BOOL) return SL_REG_INVALID; *out=v->b; return SL_REG_OK; } sl_reg_status sl_reg_value_kind(const sl_registry *r,const char *path,const char *name,sl_reg_kind *kind){ if(!r||!path||!name||!kind) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k) return SL_REG_NOT_FOUND; RegValue *v=find_val(k,name); if(!v) return SL_REG_NOT_FOUND; *kind=v->kind; return SL_REG_OK; } sl_reg_status sl_reg_feature_set(sl_registry *r,const char *name,int enabled){ char p[SL_REG_PATH_CAP]; snprintf(p,sizeof p,"Features"); (void)name; return sl_reg_set_bool(r,p,name,enabled); } int sl_reg_feature_enabled(const sl_registry *r,const char *name){ int out=0; if(sl_reg_get_bool(r,"Features",name,&out)==SL_REG_OK) return out; return 0; } /* ---- provenance ------------------------------------------------------- */ sl_reg_status sl_reg_provenance_set(sl_registry *r,const char *path,const sl_reg_provenance *p){ if(!r||!path||!p) return SL_REG_INVALID; sl_reg_key_create(r,path); RegKey *k=find_key(r,path); if(!k) return SL_REG_LIMIT; k->prov=*p; if(k->prov.seal[0]=='\0') sl_reg_seal(&k->prov); k->has_prov=1; return SL_REG_OK; } sl_reg_status sl_reg_provenance_get(const sl_registry *r,const char *path,sl_reg_provenance *out){ if(!r||!path||!out) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k||!k->has_prov) return SL_REG_NOT_FOUND; *out=k->prov; return SL_REG_OK; } /* ---- seed ------------------------------------------------------------- */ sl_reg_status sl_reg_seed_defaults(sl_registry *r){ if(!r) return SL_REG_INVALID; sl_reg_key_create(r,"System"); sl_reg_set_string(r,"System","name","Idea System(TM) / SLeeLa"); sl_reg_set_string(r,"System","registryVersion",SLEELA_REGISTRY_VERSION); sl_reg_key_create(r,"System/VM"); sl_reg_set_string(r,"System/VM","default","native"); sl_reg_key_create(r,"Settings"); sl_reg_set_int(r,"Settings","memoryLimitMiB",2048); sl_reg_set_int(r,"Settings","threadCap",128); sl_reg_set_string(r,"Settings","verbosity","normal"); sl_reg_key_create(r,"Features"); sl_reg_set_bool(r,"Features","modium",1); sl_reg_set_bool(r,"Features","vmSelect",1); sl_reg_set_bool(r,"Features","premiumVms",1); sl_reg_key_create(r,"Artifacts"); /* Math: precision-norm defaults + the pi catalog locators. Mirrors the * SLeeLa model in lib/registry/SLRegistry.sleela seedDefaults(). The large * pi value is referenced by LOCATOR only (per REGISTRY-3.0-MODIUM.md the * registry never stores the bytes); Modium resolves the path to the * installed file and loads it at subsystem startup. */ sl_reg_key_create(r,"Math"); sl_reg_set_int(r,"Math","irrationalDigitCarry",2048); sl_reg_set_int(r,"Math","repeatingDigitCarry",58); sl_reg_set_int(r,"Math","financeCarry",1023); sl_reg_set_int(r,"Math","piReferenceDigits",2048); sl_reg_set_string(r,"Math","piReference", "3.141592653589793238462643383279502884197169399375105820974944"); sl_reg_set_int(r,"Math","piReferenceLargeDigits",100000000); sl_reg_set_string(r,"Math","piReferenceLargePath","pi-generator/pi.100000000.digits"); return SL_REG_OK; } /* ---- persistence (.sleelareg text format) ----------------------------- */ sl_reg_status sl_reg_save(const sl_registry *r,const char *path){ if(!r||!path) return SL_REG_INVALID; FILE *f=fopen(path,"wb"); if(!f) return SL_REG_INVALID; fprintf(f,"%s %d\n",SLEELA_REGISTRY_MAGIC,SLEELA_REGISTRY_FORMAT); for(int i=0;inkeys;++i){ const RegKey *k=&r->keys[i]; if(!k->used) continue; fprintf(f,"[%s]\n",k->path); for(int j=0;jnvalues;++j){ const RegValue *v=&k->values[j]; if(!v->used) continue; if(v->kind==SL_REG_STRING) fprintf(f,"= s %s %s\n",v->name,v->s); else if(v->kind==SL_REG_INT) fprintf(f,"= i %s %ld\n",v->name,v->i); else fprintf(f,"= b %s %d\n",v->name,v->b); } if(k->has_prov){ const sl_reg_provenance *p=&k->prov; fprintf(f,"@ %s | %s | %s | %s | %s | %s | %s\n", p->name,p->date,p->author,p->version,p->hex_id,p->hash,p->seal); } } fclose(f); return SL_REG_OK; } sl_reg_status sl_reg_load(sl_registry *r,const char *path){ if(!r||!path) return SL_REG_INVALID; FILE *f=fopen(path,"rb"); if(!f) return SL_REG_NOT_FOUND; char line[1024]; char cur[SL_REG_PATH_CAP]=""; if(!fgets(line,sizeof line,f)){ fclose(f); return SL_REG_MALFORMED; } if(strncmp(line,SLEELA_REGISTRY_MAGIC,5)!=0){ fclose(f); return SL_REG_MALFORMED; } r->nkeys=0; while(fgets(line,sizeof line,f)){ size_t L=strlen(line); while(L&&(line[L-1]=='\n'||line[L-1]=='\r')) line[--L]='\0'; if(line[0]=='['){ char *e=strchr(line,']'); if(e){ *e='\0'; strncpy(cur,line+1,sizeof cur-1); cur[sizeof cur-1]='\0'; sl_reg_key_create(r,cur); } } else if(line[0]=='='&&line[2]){ char t=line[2]; char nm[SL_REG_NAME_CAP]; char rest[SL_REG_STR_CAP]; if(sscanf(line+4,"%63s %255[^\n]",nm,rest)>=1){ if(t=='s') sl_reg_set_string(r,cur,nm,rest); else if(t=='i') sl_reg_set_int(r,cur,nm,strtol(rest,NULL,10)); else if(t=='b') sl_reg_set_bool(r,cur,nm,atoi(rest)); } } else if(line[0]=='@'){ sl_reg_provenance p; memset(&p,0,sizeof p); /* name | date | author | version | hexid | hash | seal */ sscanf(line+2,"%255[^|] | %31[^|] | %127[^|] | %63[^|] | %16[^|] | %64[^|] | %64[^\n]", p.name,p.date,p.author,p.version,p.hex_id,p.hash,p.seal); /* trim trailing spaces from fields */ for(char*s=p.name+strlen(p.name)-1;s>=p.name&&*s==' ';--s)*s='\0'; for(char*s=p.hash+strlen(p.hash)-1;s>=p.hash&&*s==' ';--s)*s='\0'; for(char*s=p.seal+strlen(p.seal)-1;s>=p.seal&&*s==' ';--s)*s='\0'; sl_reg_provenance_set(r,cur,&p); } } fclose(f); return SL_REG_OK; } /* ---- SQL export ------------------------------------------------------- */ static void sql_esc(const char*s,char*out,size_t cap){ size_t j=0; for(size_t i=0;s&&s[i]&&j+2 < this_file`. Deterministic (sorted).\n\n"); fprintf(f,"CREATE TABLE IF NOT EXISTS registry_entries (\n" " id INT AUTO_INCREMENT PRIMARY KEY,\n" " key_path VARCHAR(256) NOT NULL,\n" " name VARCHAR(64) NOT NULL,\n" " kind VARCHAR(8) NOT NULL,\n" " value TEXT NOT NULL,\n" " UNIQUE KEY uq_entry (key_path, name)\n);\n\n"); fprintf(f,"CREATE TABLE IF NOT EXISTS registry_provenance (\n" " id INT AUTO_INCREMENT PRIMARY KEY,\n" " key_path VARCHAR(256) NOT NULL,\n" " file VARCHAR(256) NOT NULL, date VARCHAR(32) NOT NULL,\n" " author VARCHAR(128) NOT NULL, version VARCHAR(64) NOT NULL,\n" " hex_id CHAR(16) NOT NULL, hash CHAR(64) NOT NULL, seal CHAR(64) NOT NULL,\n" " UNIQUE KEY uq_prov (key_path)\n);\n\n"); char eb[1024]; for(int i=0;inkeys;++i){ const RegKey *k=&r->keys[i]; if(!k->used) continue; for(int j=0;jnvalues;++j){ const RegValue *v=&k->values[j]; if(!v->used) continue; const char *kind = v->kind==SL_REG_STRING?"string":(v->kind==SL_REG_INT?"int":"bool"); char val[SL_REG_STR_CAP+8]; if(v->kind==SL_REG_STRING) sql_esc(v->s,val,sizeof val); else if(v->kind==SL_REG_INT) snprintf(val,sizeof val,"%ld",v->i); else snprintf(val,sizeof val,"%d",v->b); char ekp[520]; sql_esc(k->path,ekp,sizeof ekp); fprintf(f,"INSERT INTO registry_entries (key_path,name,kind,value) VALUES ('%s','%s','%s','%s');\n", ekp,v->name,kind,val); } if(k->has_prov){ const sl_reg_provenance *p=&k->prov; char ekp[520]; sql_esc(k->path,ekp,sizeof ekp); char ef[520],ea[260]; sql_esc(p->name,ef,sizeof ef); sql_esc(p->author,ea,sizeof ea); fprintf(f,"INSERT INTO registry_provenance (key_path,file,date,author,version,hex_id,hash,seal) VALUES " "('%s','%s','%s','%s','%s','%s','%s','%s');\n", ekp,ef,p->date,ea,p->version,p->hex_id,p->hash,p->seal); } } (void)eb; fclose(f); return SL_REG_OK; } /* ---- review ----------------------------------------------------------- */ long sl_reg_review(const sl_registry *r,const char *path,char *buf,size_t cap){ if(!r||!buf||cap==0) return SL_REG_INVALID; char *p=buf; char *end=buf+cap; int w; size_t plen=path?strlen(path):0; w=snprintf(p,(size_t)(end-p),"Sleela Registry %s (keys=%d values=%d provenance=%d)\n", SLEELA_REGISTRY_VERSION,sl_reg_key_count(r),sl_reg_value_count(r),sl_reg_provenance_count(r)); if(w>0&&p+wnkeys&&pkeys[i]; if(!k->used) continue; if(path&&plen>0&&!(strcmp(k->path,path)==0||(strncmp(k->path,path,plen)==0&&k->path[plen]=='/'))) continue; w=snprintf(p,(size_t)(end-p),"[%s]\n",k->path[0]?k->path:"(root)"); if(w>0&&p+wnvalues&&pvalues[j]; if(!v->used) continue; if(v->kind==SL_REG_STRING) w=snprintf(p,(size_t)(end-p)," %s = \"%s\"\n",v->name,v->s); else if(v->kind==SL_REG_INT) w=snprintf(p,(size_t)(end-p)," %s = %ld\n",v->name,v->i); else w=snprintf(p,(size_t)(end-p)," %s = %s\n",v->name,v->b?"true":"false"); if(w>0&&p+whas_prov&&pprov; w=snprintf(p,(size_t)(end-p), " file=%s author=%s version=%s hexid=%s\n" " hash=%s seal=%s [%s]\n", pr->name,pr->author,pr->version,pr->hex_id,pr->hash,pr->seal, sl_reg_seal_verify(pr)?"SEALED":"BROKEN"); if(w>0&&p+wnkeys;++i) if(r->keys[i].used)c++; return c; } int sl_reg_value_count(const sl_registry *r){ int c=0; for(int i=0;inkeys;++i){ if(!r->keys[i].used)continue; for(int j=0;jkeys[i].nvalues;++j) if(r->keys[i].values[j].used)c++; } return c; } int sl_reg_provenance_count(const sl_registry *r){ int c=0; for(int i=0;inkeys;++i) if(r->keys[i].used&&r->keys[i].has_prov)c++; return c; } const char *sl_reg_status_name(sl_reg_status s){ switch(s){ case SL_REG_OK: return "OK"; case SL_REG_INVALID: return "INVALID"; case SL_REG_NOT_FOUND: return "NOT_FOUND"; case SL_REG_EXISTS: return "EXISTS"; case SL_REG_LIMIT: return "LIMIT"; case SL_REG_MALFORMED: return "MALFORMED"; case SL_REG_SEAL_BROKEN: return "SEAL_BROKEN"; default: return "UNKNOWN"; } }