data.c 86 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687
  1. /* snac - A simple, minimalistic ActivityPub instance */
  2. /* copyright (c) 2022 - 2024 grunfink et al. / MIT license */
  3. #include "xs.h"
  4. #include "xs_hex.h"
  5. #include "xs_io.h"
  6. #include "xs_json.h"
  7. #include "xs_openssl.h"
  8. #include "xs_glob.h"
  9. #include "xs_set.h"
  10. #include "xs_time.h"
  11. #include "xs_regex.h"
  12. #include "xs_match.h"
  13. #include "xs_unicode.h"
  14. #include "xs_random.h"
  15. #include "snac.h"
  16. #include <time.h>
  17. #include <sys/stat.h>
  18. #include <sys/file.h>
  19. #include <sys/time.h>
  20. #include <fcntl.h>
  21. #include <pthread.h>
  22. double disk_layout = 2.7;
  23. /* storage serializer */
  24. pthread_mutex_t data_mutex = {0};
  25. int snac_upgrade(xs_str **error);
  26. int srv_open(const char *basedir, int auto_upgrade)
  27. /* opens a server */
  28. {
  29. int ret = 0;
  30. xs *cfg_file = NULL;
  31. FILE *f;
  32. xs_str *error = NULL;
  33. pthread_mutex_init(&data_mutex, NULL);
  34. srv_basedir = xs_str_new(basedir);
  35. if (xs_endswith(srv_basedir, "/"))
  36. srv_basedir = xs_crop_i(srv_basedir, 0, -1);
  37. cfg_file = xs_fmt("%s/server.json", basedir);
  38. if ((f = fopen(cfg_file, "r")) == NULL)
  39. error = xs_fmt("ERROR: cannot open '%s'", cfg_file);
  40. else {
  41. /* read full config file */
  42. srv_config = xs_json_load(f);
  43. fclose(f);
  44. /* parse */
  45. if (srv_config == NULL)
  46. error = xs_fmt("ERROR: cannot parse '%s'", cfg_file);
  47. else {
  48. const char *host;
  49. const char *prefix;
  50. const char *dbglvl;
  51. const char *proto;
  52. host = xs_dict_get(srv_config, "host");
  53. prefix = xs_dict_get(srv_config, "prefix");
  54. dbglvl = xs_dict_get(srv_config, "dbglevel");
  55. proto = xs_dict_get_def(srv_config, "protocol", "https");
  56. if (host == NULL || prefix == NULL)
  57. error = xs_str_new("ERROR: cannot get server data");
  58. else {
  59. srv_baseurl = xs_fmt("%s:/" "/%s%s", proto, host, prefix);
  60. dbglevel = (int) xs_number_get(dbglvl);
  61. if ((dbglvl = getenv("DEBUG")) != NULL) {
  62. dbglevel = atoi(dbglvl);
  63. error = xs_fmt("DEBUG level set to %d from environment", dbglevel);
  64. }
  65. if (auto_upgrade)
  66. ret = snac_upgrade(&error);
  67. else {
  68. if (xs_number_get(xs_dict_get(srv_config, "layout")) < disk_layout)
  69. error = xs_fmt("ERROR: disk layout changed - execute 'snac upgrade' first");
  70. else
  71. ret = 1;
  72. }
  73. }
  74. }
  75. }
  76. if (error != NULL)
  77. srv_log(error);
  78. /* create the queue/ subdir, just in case */
  79. xs *qdir = xs_fmt("%s/queue", srv_basedir);
  80. mkdirx(qdir);
  81. xs *ibdir = xs_fmt("%s/inbox", srv_basedir);
  82. mkdirx(ibdir);
  83. xs *tmpdir = xs_fmt("%s/tmp", srv_basedir);
  84. mkdirx(tmpdir);
  85. #ifdef __APPLE__
  86. /* Apple uses st_atimespec instead of st_atim etc */
  87. #define st_atim st_atimespec
  88. #define st_ctim st_ctimespec
  89. #define st_mtim st_mtimespec
  90. #endif
  91. #ifdef __OpenBSD__
  92. if (xs_is_true(xs_dict_get(srv_config, "disable_openbsd_security"))) {
  93. srv_debug(1, xs_dup("OpenBSD security disabled by admin"));
  94. }
  95. else {
  96. int smail = !xs_is_true(xs_dict_get(srv_config, "disable_email_notifications"));
  97. const char *address = xs_dict_get(srv_config, "address");
  98. srv_debug(1, xs_fmt("Calling unveil()"));
  99. unveil(basedir, "rwc");
  100. unveil("/tmp", "rwc");
  101. unveil("/etc/resolv.conf", "r");
  102. unveil("/etc/hosts", "r");
  103. unveil("/etc/ssl/openssl.cnf", "r");
  104. unveil("/etc/ssl/cert.pem", "r");
  105. unveil("/usr/share/zoneinfo", "r");
  106. if (smail)
  107. unveil("/usr/sbin/sendmail", "x");
  108. if (*address == '/')
  109. unveil(address, "rwc");
  110. unveil(NULL, NULL);
  111. srv_debug(1, xs_fmt("Calling pledge()"));
  112. xs *p = xs_str_new("stdio rpath wpath cpath flock inet proc dns fattr");
  113. if (smail)
  114. p = xs_str_cat(p, " exec");
  115. if (*address == '/')
  116. p = xs_str_cat(p, " unix");
  117. pledge(p, NULL);
  118. }
  119. #endif /* __OpenBSD__ */
  120. /* read (and drop) emojis.json, possibly creating it */
  121. xs_free(emojis());
  122. /* if style.css does not exist, create it */
  123. xs *css_fn = xs_fmt("%s/style.css", srv_basedir);
  124. if (mtime(css_fn) == 0) {
  125. srv_log(xs_fmt("Writing style.css"));
  126. write_default_css();
  127. }
  128. /* create the proxy token seed */
  129. {
  130. char rnd[16];
  131. xs_rnd_buf(rnd, sizeof(rnd));
  132. srv_proxy_token_seed = xs_hex_enc(rnd, sizeof(rnd));
  133. }
  134. return ret;
  135. }
  136. void srv_free(void)
  137. {
  138. xs_free(srv_basedir);
  139. xs_free(srv_config);
  140. xs_free(srv_baseurl);
  141. pthread_mutex_destroy(&data_mutex);
  142. }
  143. void user_free(snac *snac)
  144. /* frees a user snac */
  145. {
  146. xs_free(snac->uid);
  147. xs_free(snac->basedir);
  148. xs_free(snac->config);
  149. xs_free(snac->config_o);
  150. xs_free(snac->key);
  151. xs_free(snac->links);
  152. xs_free(snac->actor);
  153. xs_free(snac->md5);
  154. }
  155. int user_open(snac *user, const char *uid)
  156. /* opens a user */
  157. {
  158. int ret = 0;
  159. *user = (snac){0};
  160. if (validate_uid(uid)) {
  161. xs *cfg_file = NULL;
  162. FILE *f;
  163. xs *t = xs_fmt("%s/user/%s", srv_basedir, uid);
  164. if (mtime(t) == 0.0) {
  165. /* user folder does not exist; try with a different case */
  166. xs *lcuid = xs_tolower_i(xs_dup(uid));
  167. xs *ulist = user_list();
  168. xs_list *p = ulist;
  169. const xs_str *v;
  170. while (xs_list_iter(&p, &v)) {
  171. xs *v2 = xs_tolower_i(xs_dup(v));
  172. if (strcmp(lcuid, v2) == 0) {
  173. user->uid = xs_dup(v);
  174. break;
  175. }
  176. }
  177. }
  178. else
  179. user->uid = xs_str_new(uid);
  180. if (user->uid == NULL)
  181. return ret;
  182. user->basedir = xs_fmt("%s/user/%s", srv_basedir, user->uid);
  183. cfg_file = xs_fmt("%s/user.json", user->basedir);
  184. if ((f = fopen(cfg_file, "r")) != NULL) {
  185. /* read full config file */
  186. user->config = xs_json_load(f);
  187. fclose(f);
  188. if (user->config != NULL) {
  189. xs *key_file = xs_fmt("%s/key.json", user->basedir);
  190. if ((f = fopen(key_file, "r")) != NULL) {
  191. user->key = xs_json_load(f);
  192. fclose(f);
  193. if (user->key != NULL) {
  194. user->actor = xs_fmt("%s/%s", srv_baseurl, user->uid);
  195. user->md5 = xs_md5_hex(user->actor, strlen(user->actor));
  196. /* everything is ok right now */
  197. ret = 1;
  198. /* does it have a configuration override? */
  199. xs *cfg_file_o = xs_fmt("%s/user_o.json", user->basedir);
  200. if ((f = fopen(cfg_file_o, "r")) != NULL) {
  201. user->config_o = xs_json_load(f);
  202. fclose(f);
  203. if (user->config_o == NULL)
  204. srv_log(xs_fmt("error parsing '%s'", cfg_file_o));
  205. }
  206. if (user->config_o == NULL)
  207. user->config_o = xs_dict_new();
  208. }
  209. else
  210. srv_log(xs_fmt("error parsing '%s'", key_file));
  211. }
  212. else
  213. srv_log(xs_fmt("error opening '%s' %d", key_file, errno));
  214. }
  215. else
  216. srv_log(xs_fmt("error parsing '%s'", cfg_file));
  217. }
  218. else
  219. srv_debug(2, xs_fmt("error opening '%s' %d", cfg_file, errno));
  220. /* verified links */
  221. xs *links_file = xs_fmt("%s/links.json", user->basedir);
  222. if ((f = fopen(links_file, "r")) != NULL) {
  223. user->links = xs_json_load(f);
  224. fclose(f);
  225. }
  226. }
  227. else
  228. srv_debug(1, xs_fmt("invalid user '%s'", uid));
  229. if (!ret)
  230. user_free(user);
  231. return ret;
  232. }
  233. xs_list *user_list(void)
  234. /* returns the list of user ids */
  235. {
  236. xs *spec = xs_fmt("%s/user/" "*", srv_basedir);
  237. return xs_glob(spec, 1, 0);
  238. }
  239. int user_open_by_md5(snac *snac, const char *md5)
  240. /* iterates all users searching by md5 */
  241. {
  242. xs *ulist = user_list();
  243. xs_list *p = ulist;
  244. const xs_str *v;
  245. while (xs_list_iter(&p, &v)) {
  246. user_open(snac, v);
  247. if (strcmp(snac->md5, md5) == 0)
  248. return 1;
  249. user_free(snac);
  250. }
  251. return 0;
  252. }
  253. int user_persist(snac *snac, int publish)
  254. /* store user */
  255. {
  256. xs *fn = xs_fmt("%s/user.json", snac->basedir);
  257. xs *bfn = xs_fmt("%s.bak", fn);
  258. FILE *f;
  259. rename(fn, bfn);
  260. if ((f = fopen(fn, "w")) != NULL) {
  261. xs_json_dump(snac->config, 4, f);
  262. fclose(f);
  263. }
  264. else
  265. rename(bfn, fn);
  266. history_del(snac, "timeline.html_");
  267. timeline_touch(snac);
  268. if (publish) {
  269. xs *a_msg = msg_actor(snac);
  270. xs *u_msg = msg_update(snac, a_msg);
  271. enqueue_message(snac, u_msg);
  272. enqueue_verify_links(snac);
  273. }
  274. return 0;
  275. }
  276. double mtime_nl(const char *fn, int *n_link)
  277. /* returns the mtime and number of links of a file or directory, or 0.0 */
  278. {
  279. struct stat st;
  280. double r = 0.0;
  281. int n = 0;
  282. if (fn && stat(fn, &st) != -1) {
  283. r = (double) st.st_mtim.tv_sec;
  284. n = st.st_nlink;
  285. }
  286. if (n_link)
  287. *n_link = n;
  288. return r;
  289. }
  290. #define MIN(v1, v2) ((v1) < (v2) ? (v1) : (v2))
  291. double f_ctime(const char *fn)
  292. /* returns the ctime of a file or directory, or 0.0 */
  293. {
  294. struct stat st;
  295. double r = 0.0;
  296. if (fn && stat(fn, &st) != -1) {
  297. /* return the lowest of ctime and mtime;
  298. there are operations that change the ctime, like link() */
  299. r = (double) MIN(st.st_ctim.tv_sec, st.st_mtim.tv_sec);
  300. }
  301. return r;
  302. }
  303. int is_md5_hex(const char *md5)
  304. {
  305. return xs_is_hex(md5) && strlen(md5) == MD5_HEX_SIZE - 1;
  306. }
  307. /** database 2.1+ **/
  308. /** indexes **/
  309. int index_add_md5(const char *fn, const char *md5)
  310. /* adds an md5 to an index */
  311. {
  312. int status = HTTP_STATUS_CREATED;
  313. FILE *f;
  314. if (!is_md5_hex(md5)) {
  315. srv_log(xs_fmt("index_add_md5: bad md5 %s %s", fn, md5));
  316. return HTTP_STATUS_BAD_REQUEST;
  317. }
  318. pthread_mutex_lock(&data_mutex);
  319. if ((f = fopen(fn, "a")) != NULL) {
  320. flock(fileno(f), LOCK_EX);
  321. /* ensure the position is at the end after getting the lock */
  322. fseek(f, 0, SEEK_END);
  323. fprintf(f, "%s\n", md5);
  324. fclose(f);
  325. }
  326. else
  327. status = HTTP_STATUS_INTERNAL_SERVER_ERROR;
  328. pthread_mutex_unlock(&data_mutex);
  329. return status;
  330. }
  331. int index_add(const char *fn, const char *id)
  332. /* adds an id to an index */
  333. {
  334. xs *md5 = xs_md5_hex(id, strlen(id));
  335. return index_add_md5(fn, md5);
  336. }
  337. int index_del_md5(const char *fn, const char *md5)
  338. /* deletes an md5 from an index */
  339. {
  340. int status = HTTP_STATUS_NOT_FOUND;
  341. FILE *f;
  342. pthread_mutex_lock(&data_mutex);
  343. if ((f = fopen(fn, "r+")) != NULL) {
  344. char line[256];
  345. while (fgets(line, sizeof(line), f) != NULL) {
  346. line[MD5_HEX_SIZE - 1] = '\0';
  347. if (strcmp(line, md5) == 0) {
  348. /* found! just rewind, overwrite it with garbage
  349. and an eventual call to index_gc() will clean it
  350. [yes: this breaks index_len()] */
  351. fseek(f, -MD5_HEX_SIZE, SEEK_CUR);
  352. fwrite("-", 1, 1, f);
  353. status = HTTP_STATUS_OK;
  354. break;
  355. }
  356. }
  357. fclose(f);
  358. }
  359. else
  360. status = HTTP_STATUS_GONE;
  361. pthread_mutex_unlock(&data_mutex);
  362. return status;
  363. }
  364. int index_del(const char *fn, const char *id)
  365. /* deletes an id from an index */
  366. {
  367. xs *md5 = xs_md5_hex(id, strlen(id));
  368. return index_del_md5(fn, md5);
  369. }
  370. int index_gc(const char *fn)
  371. /* garbage-collects an index, deleting objects that are not here */
  372. {
  373. FILE *i, *o;
  374. int gc = -1;
  375. pthread_mutex_lock(&data_mutex);
  376. if ((i = fopen(fn, "r")) != NULL) {
  377. xs *nfn = xs_fmt("%s.new", fn);
  378. char line[256];
  379. if ((o = fopen(nfn, "w")) != NULL) {
  380. gc = 0;
  381. while (fgets(line, sizeof(line), i) != NULL) {
  382. line[MD5_HEX_SIZE - 1] = '\0';
  383. if (line[0] != '-' && object_here_by_md5(line))
  384. fprintf(o, "%s\n", line);
  385. else
  386. gc++;
  387. }
  388. fclose(o);
  389. xs *ofn = xs_fmt("%s.bak", fn);
  390. unlink(ofn);
  391. link(fn, ofn);
  392. rename(nfn, fn);
  393. }
  394. fclose(i);
  395. }
  396. pthread_mutex_unlock(&data_mutex);
  397. return gc;
  398. }
  399. int index_in_md5(const char *fn, const char *md5)
  400. /* checks if the md5 is already in the index */
  401. {
  402. FILE *f;
  403. int ret = 0;
  404. if ((f = fopen(fn, "r")) != NULL) {
  405. flock(fileno(f), LOCK_SH);
  406. char line[256];
  407. while (!ret && fgets(line, sizeof(line), f) != NULL) {
  408. line[MD5_HEX_SIZE - 1] = '\0';
  409. if (strcmp(line, md5) == 0)
  410. ret = 1;
  411. }
  412. fclose(f);
  413. }
  414. return ret;
  415. }
  416. int index_in(const char *fn, const char *id)
  417. /* checks if the object id is already in the index */
  418. {
  419. xs *md5 = xs_md5_hex(id, strlen(id));
  420. return index_in_md5(fn, md5);
  421. }
  422. int index_first(const char *fn, char md5[MD5_HEX_SIZE])
  423. /* reads the first entry of an index */
  424. {
  425. FILE *f;
  426. int ret = 0;
  427. if ((f = fopen(fn, "r")) != NULL) {
  428. if (fread(md5, MD5_HEX_SIZE, 1, f)) {
  429. md5[MD5_HEX_SIZE - 1] = '\0';
  430. ret = 1;
  431. }
  432. fclose(f);
  433. }
  434. return ret;
  435. }
  436. int index_len(const char *fn)
  437. /* returns the number of elements in an index */
  438. {
  439. struct stat st;
  440. int len = 0;
  441. if (stat(fn, &st) != -1)
  442. len = st.st_size / MD5_HEX_SIZE;
  443. return len;
  444. }
  445. xs_list *index_list(const char *fn, int max)
  446. /* returns an index as a list */
  447. {
  448. xs_list *list = xs_list_new();
  449. FILE *f;
  450. int n = 0;
  451. if ((f = fopen(fn, "r")) != NULL) {
  452. flock(fileno(f), LOCK_SH);
  453. char line[256];
  454. while (n < max && fgets(line, sizeof(line), f) != NULL) {
  455. if (line[0] != '-') {
  456. line[MD5_HEX_SIZE - 1] = '\0';
  457. list = xs_list_append(list, line);
  458. n++;
  459. }
  460. }
  461. fclose(f);
  462. }
  463. return list;
  464. }
  465. int index_desc_next(FILE *f, char md5[MD5_HEX_SIZE])
  466. /* reads the next entry of a desc index */
  467. {
  468. for (;;) {
  469. /* move backwards 2 entries */
  470. if (fseek(f, MD5_HEX_SIZE * -2, SEEK_CUR) == -1)
  471. return 0;
  472. /* read and md5 */
  473. if (!fread(md5, MD5_HEX_SIZE, 1, f))
  474. return 0;
  475. if (md5[0] != '-')
  476. break;
  477. }
  478. md5[MD5_HEX_SIZE - 1] = '\0';
  479. return 1;
  480. }
  481. int index_desc_first(FILE *f, char md5[MD5_HEX_SIZE], int skip)
  482. /* reads the first entry of a desc index */
  483. {
  484. /* try to position at the end and then back to the first element */
  485. if (fseek(f, 0, SEEK_END) || fseek(f, (skip + 1) * -MD5_HEX_SIZE, SEEK_CUR))
  486. return 0;
  487. /* try to read an md5 */
  488. if (!fread(md5, MD5_HEX_SIZE, 1, f))
  489. return 0;
  490. /* null-terminate */
  491. md5[MD5_HEX_SIZE - 1] = '\0';
  492. /* deleted? retry next */
  493. if (md5[0] == '-')
  494. return index_desc_next(f, md5);
  495. return 1;
  496. }
  497. xs_list *index_list_desc(const char *fn, int skip, int show)
  498. /* returns an index as a list, in reverse order */
  499. {
  500. xs_list *list = xs_list_new();
  501. FILE *f;
  502. if ((f = fopen(fn, "r")) != NULL) {
  503. char md5[MD5_HEX_SIZE];
  504. if (index_desc_first(f, md5, skip)) {
  505. int n = 1;
  506. do {
  507. list = xs_list_append(list, md5);
  508. } while (n++ < show && index_desc_next(f, md5));
  509. }
  510. fclose(f);
  511. }
  512. return list;
  513. }
  514. /** objects **/
  515. static xs_str *_object_fn_by_md5(const char *md5, const char *func)
  516. {
  517. xs *bfn = xs_fmt("%s/object/%c%c", srv_basedir, md5[0], md5[1]);
  518. xs_str *ret;
  519. int ok = 1;
  520. /* an object deleted from an index; fail but don't bark */
  521. if (md5[0] == '-')
  522. ok = 0;
  523. else
  524. if (!is_md5_hex(md5)) {
  525. srv_log(xs_fmt("_object_fn_by_md5() [from %s()]: bad md5 '%s'", func, md5));
  526. ok = 0;
  527. }
  528. if (ok) {
  529. mkdirx(bfn);
  530. ret = xs_fmt("%s/%s.json", bfn, md5);
  531. }
  532. else
  533. ret = xs_fmt("%s/object/invalid/invalid.json", srv_basedir);
  534. return ret;
  535. }
  536. static xs_str *_object_fn(const char *id)
  537. {
  538. xs *md5 = xs_md5_hex(id, strlen(id));
  539. return _object_fn_by_md5(md5, "_object_fn");
  540. }
  541. int object_here_by_md5(const char *id)
  542. /* checks if an object is already downloaded */
  543. {
  544. xs *fn = _object_fn_by_md5(id, "object_here_by_md5");
  545. return mtime(fn) > 0.0;
  546. }
  547. int object_here(const char *id)
  548. /* checks if an object is already downloaded */
  549. {
  550. xs *fn = _object_fn(id);
  551. return mtime(fn) > 0.0;
  552. }
  553. int object_get_by_md5(const char *md5, xs_dict **obj)
  554. /* returns a stored object, optionally of the requested type */
  555. {
  556. int status = HTTP_STATUS_NOT_FOUND;
  557. xs *fn = _object_fn_by_md5(md5, "object_get_by_md5");
  558. FILE *f;
  559. if ((f = fopen(fn, "r")) != NULL) {
  560. *obj = xs_json_load(f);
  561. fclose(f);
  562. if (*obj)
  563. status = HTTP_STATUS_OK;
  564. }
  565. else
  566. *obj = NULL;
  567. return status;
  568. }
  569. int object_get(const char *id, xs_dict **obj)
  570. /* returns a stored object, optionally of the requested type */
  571. {
  572. xs *md5 = xs_md5_hex(id, strlen(id));
  573. return object_get_by_md5(md5, obj);
  574. }
  575. int _object_add(const char *id, const xs_dict *obj, int ow)
  576. /* stores an object */
  577. {
  578. int status = HTTP_STATUS_CREATED; /* Created */
  579. xs *fn = _object_fn(id);
  580. FILE *f;
  581. if (mtime(fn) > 0.0) {
  582. if (!ow) {
  583. /* object already here */
  584. srv_debug(1, xs_fmt("object_add object already here %s", id));
  585. return HTTP_STATUS_NO_CONTENT;
  586. }
  587. else
  588. status = HTTP_STATUS_OK;
  589. }
  590. if ((f = fopen(fn, "w")) != NULL) {
  591. flock(fileno(f), LOCK_EX);
  592. xs_json_dump(obj, 4, f);
  593. fclose(f);
  594. /* does this object has a parent? */
  595. const char *in_reply_to = get_in_reply_to(obj);
  596. if (!xs_is_null(in_reply_to) && *in_reply_to) {
  597. /* update the children index of the parent */
  598. xs *c_idx = _object_fn(in_reply_to);
  599. c_idx = xs_replace_i(c_idx, ".json", "_c.idx");
  600. if (!index_in(c_idx, id)) {
  601. index_add(c_idx, id);
  602. srv_debug(1, xs_fmt("object_add added child %s to %s", id, c_idx));
  603. }
  604. else
  605. srv_debug(1, xs_fmt("object_add %s child already in %s", id, c_idx));
  606. /* create a one-element index with the parent */
  607. xs *p_idx = xs_replace(fn, ".json", "_p.idx");
  608. if (mtime(p_idx) == 0.0) {
  609. index_add(p_idx, in_reply_to);
  610. srv_debug(1, xs_fmt("object_add added parent %s to %s", in_reply_to, p_idx));
  611. }
  612. }
  613. }
  614. else {
  615. srv_log(xs_fmt("object_add error writing %s (errno: %d)", fn, errno));
  616. status = HTTP_STATUS_INTERNAL_SERVER_ERROR;
  617. }
  618. srv_debug(1, xs_fmt("object_add %s %s %d", id, fn, status));
  619. return status;
  620. }
  621. int object_add(const char *id, const xs_dict *obj)
  622. /* stores an object */
  623. {
  624. return _object_add(id, obj, 0);
  625. }
  626. int object_add_ow(const char *id, const xs_dict *obj)
  627. /* stores an object (overwriting allowed) */
  628. {
  629. return _object_add(id, obj, 1);
  630. }
  631. int object_del_by_md5(const char *md5)
  632. /* deletes an object by its md5 */
  633. {
  634. int status = HTTP_STATUS_NOT_FOUND;
  635. xs *fn = _object_fn_by_md5(md5, "object_del_by_md5");
  636. if (unlink(fn) != -1) {
  637. status = HTTP_STATUS_OK;
  638. /* also delete associated indexes */
  639. xs *spec = xs_dup(fn);
  640. spec = xs_replace_i(spec, ".json", "*.idx");
  641. xs *files = xs_glob(spec, 0, 0);
  642. char *p;
  643. const char *v;
  644. p = files;
  645. while (xs_list_iter(&p, &v)) {
  646. srv_debug(1, xs_fmt("object_del index %s", v));
  647. unlink(v);
  648. }
  649. }
  650. srv_debug(1, xs_fmt("object_del %s %d", fn, status));
  651. return status;
  652. }
  653. int object_del(const char *id)
  654. /* deletes an object */
  655. {
  656. xs *md5 = xs_md5_hex(id, strlen(id));
  657. return object_del_by_md5(md5);
  658. }
  659. int object_del_if_unref(const char *id)
  660. /* deletes an object if its n_links < 2 */
  661. {
  662. xs *fn = _object_fn(id);
  663. int n_links;
  664. int ret = 0;
  665. if (mtime_nl(fn, &n_links) > 0.0 && n_links < 2)
  666. ret = object_del(id);
  667. return ret;
  668. }
  669. double object_ctime_by_md5(const char *md5)
  670. {
  671. xs *fn = _object_fn_by_md5(md5, "object_ctime_by_md5");
  672. return f_ctime(fn);
  673. }
  674. double object_ctime(const char *id)
  675. {
  676. xs *md5 = xs_md5_hex(id, strlen(id));
  677. return object_ctime_by_md5(md5);
  678. }
  679. double object_mtime_by_md5(const char *md5)
  680. {
  681. xs *fn = _object_fn_by_md5(md5, "object_mtime_by_md5");
  682. return mtime(fn);
  683. }
  684. double object_mtime(const char *id)
  685. {
  686. xs *md5 = xs_md5_hex(id, strlen(id));
  687. return object_mtime_by_md5(md5);
  688. }
  689. void object_touch(const char *id)
  690. {
  691. xs *md5 = xs_md5_hex(id, strlen(id));
  692. xs *fn = _object_fn_by_md5(md5, "object_touch");
  693. if (mtime(fn))
  694. utimes(fn, NULL);
  695. }
  696. xs_str *_object_index_fn(const char *id, const char *idxsfx)
  697. /* returns the filename of an object's index */
  698. {
  699. xs_str *fn = _object_fn(id);
  700. return xs_replace_i(fn, ".json", idxsfx);
  701. }
  702. int object_likes_len(const char *id)
  703. /* returns the number of likes (without reading the index) */
  704. {
  705. xs *fn = _object_index_fn(id, "_l.idx");
  706. return index_len(fn);
  707. }
  708. int object_announces_len(const char *id)
  709. /* returns the number of announces (without reading the index) */
  710. {
  711. xs *fn = _object_index_fn(id, "_a.idx");
  712. return index_len(fn);
  713. }
  714. xs_list *object_children(const char *id)
  715. /* returns the list of an object's children */
  716. {
  717. xs *fn = _object_index_fn(id, "_c.idx");
  718. return index_list(fn, XS_ALL);
  719. }
  720. xs_list *object_likes(const char *id)
  721. {
  722. xs *fn = _object_index_fn(id, "_l.idx");
  723. return index_list(fn, XS_ALL);
  724. }
  725. xs_list *object_announces(const char *id)
  726. {
  727. xs *fn = _object_index_fn(id, "_a.idx");
  728. return index_list(fn, XS_ALL);
  729. }
  730. int object_parent(const char *md5, char parent[MD5_HEX_SIZE])
  731. /* returns the object parent, if any */
  732. {
  733. xs *fn = _object_fn_by_md5(md5, "object_parent");
  734. fn = xs_replace_i(fn, ".json", "_p.idx");
  735. return index_first(fn, parent);
  736. }
  737. int object_admire(const char *id, const char *actor, int like)
  738. /* actor likes or announces this object */
  739. {
  740. int status = HTTP_STATUS_OK;
  741. xs *fn = _object_fn(id);
  742. fn = xs_replace_i(fn, ".json", like ? "_l.idx" : "_a.idx");
  743. if (!index_in(fn, actor)) {
  744. status = index_add(fn, actor);
  745. srv_debug(1, xs_fmt("object_admire (%s) %s %s", like ? "Like" : "Announce", actor, fn));
  746. }
  747. return status;
  748. }
  749. int object_unadmire(const char *id, const char *actor, int like)
  750. /* actor no longer likes or announces this object */
  751. {
  752. int status;
  753. xs *fn = _object_fn(id);
  754. fn = xs_replace_i(fn, ".json", like ? "_l.idx" : "_a.idx");
  755. status = index_del(fn, actor);
  756. if (valid_status(status))
  757. index_gc(fn);
  758. srv_debug(0,
  759. xs_fmt("object_unadmire (%s) %s %s %d", like ? "Like" : "Announce", actor, fn, status));
  760. return status;
  761. }
  762. xs_str *object_user_cache_fn_by_md5(snac *user, const char *md5, const char *cachedir)
  763. {
  764. return xs_fmt("%s/%s/%s.json", user->basedir, cachedir, md5);
  765. }
  766. xs_str *object_user_cache_fn(snac *user, const char *id, const char *cachedir)
  767. {
  768. xs *md5 = xs_md5_hex(id, strlen(id));
  769. return object_user_cache_fn_by_md5(user, md5, cachedir);
  770. }
  771. xs_str *object_user_cache_index_fn(snac *user, const char *cachedir)
  772. {
  773. return xs_fmt("%s/%s.idx", user->basedir, cachedir);
  774. }
  775. int _object_user_cache(snac *user, const char *id, const char *cachedir, int del)
  776. /* adds or deletes from a user cache */
  777. {
  778. xs *ofn = _object_fn(id);
  779. xs *cfn = object_user_cache_fn(user, id, cachedir);
  780. xs *idx = object_user_cache_index_fn(user, cachedir);
  781. int ret;
  782. if (del) {
  783. ret = unlink(cfn);
  784. index_del(idx, id);
  785. }
  786. else {
  787. /* create the subfolder, if it does not exist */
  788. xs *dir = xs_fmt("%s/%s/", user->basedir, cachedir);
  789. mkdirx(dir);
  790. if ((ret = link(ofn, cfn)) != -1)
  791. index_add(idx, id);
  792. }
  793. return ret;
  794. }
  795. int object_user_cache_add(snac *user, const char *id, const char *cachedir)
  796. /* caches an object into a user cache */
  797. {
  798. return _object_user_cache(user, id, cachedir, 0);
  799. }
  800. int object_user_cache_del(snac *user, const char *id, const char *cachedir)
  801. /* deletes an object from a user cache */
  802. {
  803. return _object_user_cache(user, id, cachedir, 1);
  804. }
  805. int object_user_cache_in(snac *user, const char *id, const char *cachedir)
  806. /* checks if an object is stored in a cache */
  807. {
  808. xs *cfn = object_user_cache_fn(user, id, cachedir);
  809. return !!(mtime(cfn) != 0.0);
  810. }
  811. int object_user_cache_in_by_md5(snac *user, const char *md5, const char *cachedir)
  812. /* checks if an object is stored in a cache */
  813. {
  814. xs *cfn = object_user_cache_fn_by_md5(user, md5, cachedir);
  815. return !!(mtime(cfn) != 0.0);
  816. }
  817. xs_list *object_user_cache_list(snac *user, const char *cachedir, int max, int inv)
  818. /* returns the objects in a cache as a list */
  819. {
  820. xs *idx = xs_fmt("%s/%s.idx", user->basedir, cachedir);
  821. return inv ? index_list_desc(idx, 0, max) : index_list(idx, max);
  822. }
  823. /** specialized functions **/
  824. /** followers **/
  825. int follower_add(snac *snac, const char *actor)
  826. /* adds a follower */
  827. {
  828. int ret = object_user_cache_add(snac, actor, "followers");
  829. snac_debug(snac, 2, xs_fmt("follower_add %s", actor));
  830. return ret == -1 ? HTTP_STATUS_INTERNAL_SERVER_ERROR : HTTP_STATUS_OK;
  831. }
  832. int follower_del(snac *snac, const char *actor)
  833. /* deletes a follower */
  834. {
  835. int ret = object_user_cache_del(snac, actor, "followers");
  836. snac_debug(snac, 2, xs_fmt("follower_del %s", actor));
  837. return ret == -1 ? HTTP_STATUS_NOT_FOUND : HTTP_STATUS_OK;
  838. }
  839. int follower_check(snac *snac, const char *actor)
  840. /* checks if someone is a follower */
  841. {
  842. return object_user_cache_in(snac, actor, "followers");
  843. }
  844. xs_list *follower_list(snac *snac)
  845. /* returns the list of followers */
  846. {
  847. xs *list = object_user_cache_list(snac, "followers", XS_ALL, 0);
  848. xs_list *fwers = xs_list_new();
  849. char *p;
  850. const char *v;
  851. /* resolve the list of md5 to be a list of actors */
  852. p = list;
  853. while (xs_list_iter(&p, &v)) {
  854. xs *a_obj = NULL;
  855. if (valid_status(object_get_by_md5(v, &a_obj))) {
  856. const char *actor = xs_dict_get(a_obj, "id");
  857. if (!xs_is_null(actor)) {
  858. /* check if the actor is still cached */
  859. xs *fn = xs_fmt("%s/followers/%s.json", snac->basedir, v);
  860. if (mtime(fn) > 0.0)
  861. fwers = xs_list_append(fwers, actor);
  862. }
  863. }
  864. }
  865. return fwers;
  866. }
  867. /** timeline **/
  868. double timeline_mtime(snac *snac)
  869. {
  870. xs *fn = xs_fmt("%s/private.idx", snac->basedir);
  871. return mtime(fn);
  872. }
  873. int timeline_touch(snac *snac)
  874. /* changes the date of the timeline index */
  875. {
  876. xs *fn = xs_fmt("%s/private.idx", snac->basedir);
  877. return utimes(fn, NULL);
  878. }
  879. xs_str *timeline_fn_by_md5(snac *snac, const char *md5)
  880. /* get the filename of an entry by md5 from any timeline */
  881. {
  882. xs_str *fn = NULL;
  883. if (is_md5_hex(md5)) {
  884. fn = xs_fmt("%s/private/%s.json", snac->basedir, md5);
  885. if (mtime(fn) == 0.0) {
  886. fn = xs_free(fn);
  887. fn = xs_fmt("%s/public/%s.json", snac->basedir, md5);
  888. if (mtime(fn) == 0.0)
  889. fn = xs_free(fn);
  890. }
  891. }
  892. return fn;
  893. }
  894. int timeline_here(snac *snac, const char *md5)
  895. /* checks if an object is in the user cache */
  896. {
  897. xs *fn = timeline_fn_by_md5(snac, md5);
  898. return !(fn == NULL);
  899. }
  900. int timeline_get_by_md5(snac *snac, const char *md5, xs_dict **msg)
  901. /* gets a message from the timeline */
  902. {
  903. int status = HTTP_STATUS_NOT_FOUND;
  904. FILE *f = NULL;
  905. xs *fn = timeline_fn_by_md5(snac, md5);
  906. if (fn != NULL && (f = fopen(fn, "r")) != NULL) {
  907. *msg = xs_json_load(f);
  908. fclose(f);
  909. if (*msg != NULL)
  910. status = HTTP_STATUS_OK;
  911. }
  912. return status;
  913. }
  914. int timeline_del(snac *snac, const char *id)
  915. /* deletes a message from the timeline */
  916. {
  917. /* delete from the user's caches */
  918. object_user_cache_del(snac, id, "public");
  919. object_user_cache_del(snac, id, "private");
  920. unpin(snac, id);
  921. unbookmark(snac, id);
  922. /* try to delete the object if it's not used elsewhere */
  923. return object_del_if_unref(id);
  924. }
  925. void timeline_update_indexes(snac *snac, const char *id)
  926. /* updates the indexes */
  927. {
  928. object_user_cache_add(snac, id, "private");
  929. if (xs_startswith(id, snac->actor)) {
  930. xs *msg = NULL;
  931. if (valid_status(object_get(id, &msg))) {
  932. /* if its ours and is public, also store in public */
  933. if (is_msg_public(msg)) {
  934. object_user_cache_add(snac, id, "public");
  935. /* also add it to the instance public timeline */
  936. xs *ipt = xs_fmt("%s/public.idx", srv_basedir);
  937. index_add(ipt, id);
  938. }
  939. }
  940. }
  941. }
  942. int timeline_add(snac *snac, const char *id, const xs_dict *o_msg)
  943. /* adds a message to the timeline */
  944. {
  945. int ret = object_add(id, o_msg);
  946. timeline_update_indexes(snac, id);
  947. tag_index(id, o_msg);
  948. list_distribute(snac, NULL, o_msg);
  949. snac_debug(snac, 1, xs_fmt("timeline_add %s", id));
  950. return ret;
  951. }
  952. int timeline_admire(snac *snac, const char *id, const char *admirer, int like)
  953. /* updates a timeline entry with a new admiration */
  954. {
  955. /* if we are admiring this, add to both timelines */
  956. if (!like && strcmp(admirer, snac->actor) == 0) {
  957. object_user_cache_add(snac, id, "public");
  958. object_user_cache_add(snac, id, "private");
  959. }
  960. int ret = object_admire(id, admirer, like);
  961. snac_debug(snac, 1, xs_fmt("timeline_admire (%s) %s %s",
  962. like ? "Like" : "Announce", id, admirer));
  963. return ret;
  964. }
  965. xs_list *timeline_top_level(snac *snac, const xs_list *list)
  966. /* returns the top level md5 entries from this index */
  967. {
  968. xs_set seen;
  969. const xs_str *v;
  970. xs_set_init(&seen);
  971. int c = 0;
  972. while (xs_list_next(list, &v, &c)) {
  973. char line[MD5_HEX_SIZE] = "";
  974. strncpy(line, v, sizeof(line));
  975. for (;;) {
  976. char line2[MD5_HEX_SIZE];
  977. /* if it doesn't have a parent, use this */
  978. if (!object_parent(line, line2))
  979. break;
  980. /* well, there is a parent... but is it here? */
  981. if (!timeline_here(snac, line2))
  982. break;
  983. /* it's here! try again with its own parent */
  984. strncpy(line, line2, sizeof(line));
  985. }
  986. xs_set_add(&seen, line);
  987. }
  988. return xs_set_result(&seen);
  989. }
  990. xs_str *user_index_fn(snac *user, const char *idx_name)
  991. /* returns the filename of a user index */
  992. {
  993. return xs_fmt("%s/%s.idx", user->basedir, idx_name);
  994. }
  995. xs_list *timeline_simple_list(snac *user, const char *idx_name, int skip, int show)
  996. /* returns a timeline (with all entries) */
  997. {
  998. xs *idx = user_index_fn(user, idx_name);
  999. return index_list_desc(idx, skip, show);
  1000. }
  1001. xs_list *timeline_list(snac *snac, const char *idx_name, int skip, int show)
  1002. /* returns a timeline (only top level entries) */
  1003. {
  1004. int c_max;
  1005. /* maximum number of items in the timeline */
  1006. c_max = xs_number_get(xs_dict_get(srv_config, "max_timeline_entries"));
  1007. /* never more timeline entries than the configured maximum */
  1008. if (show > c_max)
  1009. show = c_max;
  1010. xs *list = timeline_simple_list(snac, idx_name, skip, show);
  1011. return timeline_top_level(snac, list);
  1012. }
  1013. xs_str *instance_index_fn(void)
  1014. {
  1015. return xs_fmt("%s/public.idx", srv_basedir);
  1016. }
  1017. xs_list *timeline_instance_list(int skip, int show)
  1018. /* returns the timeline for the full instance */
  1019. {
  1020. xs *idx = instance_index_fn();
  1021. return index_list_desc(idx, skip, show);
  1022. }
  1023. /** following **/
  1024. /* this needs special treatment and cannot use the object db as is,
  1025. with a link to a cached author, because we need the Follow object
  1026. in case we need to unfollow (Undo + original Follow) */
  1027. xs_str *_following_fn(snac *snac, const char *actor)
  1028. {
  1029. xs *md5 = xs_md5_hex(actor, strlen(actor));
  1030. return xs_fmt("%s/following/%s.json", snac->basedir, md5);
  1031. }
  1032. int following_add(snac *snac, const char *actor, const xs_dict *msg)
  1033. /* adds to the following list */
  1034. {
  1035. int ret = HTTP_STATUS_CREATED;
  1036. xs *fn = _following_fn(snac, actor);
  1037. FILE *f;
  1038. xs *p_object = NULL;
  1039. if (valid_status(following_get(snac, actor, &p_object))) {
  1040. /* object already exists; if it's of type Accept,
  1041. the actor is already being followed and confirmed,
  1042. so do nothing */
  1043. const char *type = xs_dict_get(p_object, "type");
  1044. if (!xs_is_null(type) && strcmp(type, "Accept") == 0) {
  1045. snac_debug(snac, 1, xs_fmt("following_add actor already confirmed %s", actor));
  1046. return HTTP_STATUS_OK;
  1047. }
  1048. }
  1049. if ((f = fopen(fn, "w")) != NULL) {
  1050. xs_json_dump(msg, 4, f);
  1051. fclose(f);
  1052. /* get the filename of the actor object */
  1053. xs *actor_fn = _object_fn(actor);
  1054. /* increase its reference count */
  1055. fn = xs_replace_i(fn, ".json", "_a.json");
  1056. link(actor_fn, fn);
  1057. }
  1058. else
  1059. ret = HTTP_STATUS_INTERNAL_SERVER_ERROR;
  1060. snac_debug(snac, 2, xs_fmt("following_add %s %s", actor, fn));
  1061. return ret;
  1062. }
  1063. int following_del(snac *snac, const char *actor)
  1064. /* we're not following this actor any longer */
  1065. {
  1066. xs *fn = _following_fn(snac, actor);
  1067. snac_debug(snac, 2, xs_fmt("following_del %s %s", actor, fn));
  1068. unlink(fn);
  1069. /* also delete the reference to the author */
  1070. fn = xs_replace_i(fn, ".json", "_a.json");
  1071. unlink(fn);
  1072. return HTTP_STATUS_OK;
  1073. }
  1074. int following_check(snac *snac, const char *actor)
  1075. /* checks if we are following this actor */
  1076. {
  1077. xs *fn = _following_fn(snac, actor);
  1078. return !!(mtime(fn) != 0.0);
  1079. }
  1080. int following_get(snac *snac, const char *actor, xs_dict **data)
  1081. /* returns the 'Follow' object */
  1082. {
  1083. xs *fn = _following_fn(snac, actor);
  1084. FILE *f;
  1085. int status = HTTP_STATUS_OK;
  1086. if ((f = fopen(fn, "r")) != NULL) {
  1087. *data = xs_json_load(f);
  1088. fclose(f);
  1089. }
  1090. else
  1091. status = HTTP_STATUS_NOT_FOUND;
  1092. return status;
  1093. }
  1094. xs_list *following_list(snac *snac)
  1095. /* returns the list of people being followed */
  1096. {
  1097. xs *spec = xs_fmt("%s/following/" "*.json", snac->basedir);
  1098. xs *glist = xs_glob(spec, 0, 0);
  1099. xs_list *p;
  1100. const xs_str *v;
  1101. xs_list *list = xs_list_new();
  1102. /* iterate the list of files */
  1103. p = glist;
  1104. while (xs_list_iter(&p, &v)) {
  1105. FILE *f;
  1106. /* load the follower data */
  1107. if ((f = fopen(v, "r")) != NULL) {
  1108. xs *o = xs_json_load(f);
  1109. fclose(f);
  1110. if (o != NULL) {
  1111. const char *type = xs_dict_get(o, "type");
  1112. if (!xs_is_null(type) && strcmp(type, "Accept") == 0) {
  1113. const char *actor = xs_dict_get(o, "actor");
  1114. if (!xs_is_null(actor)) {
  1115. list = xs_list_append(list, actor);
  1116. /* check if there is a link to the actor object */
  1117. xs *v2 = xs_replace(v, ".json", "_a.json");
  1118. if (mtime(v2) == 0.0) {
  1119. /* no; add a link to it */
  1120. xs *actor_fn = _object_fn(actor);
  1121. link(actor_fn, v2);
  1122. }
  1123. }
  1124. }
  1125. }
  1126. }
  1127. }
  1128. return list;
  1129. }
  1130. xs_str *_muted_fn(snac *snac, const char *actor)
  1131. {
  1132. xs *md5 = xs_md5_hex(actor, strlen(actor));
  1133. return xs_fmt("%s/muted/%s", snac->basedir, md5);
  1134. }
  1135. void mute(snac *snac, const char *actor)
  1136. /* mutes a moron */
  1137. {
  1138. xs *fn = _muted_fn(snac, actor);
  1139. FILE *f;
  1140. if ((f = fopen(fn, "w")) != NULL) {
  1141. fprintf(f, "%s\n", actor);
  1142. fclose(f);
  1143. snac_debug(snac, 2, xs_fmt("muted %s %s", actor, fn));
  1144. }
  1145. }
  1146. void unmute(snac *snac, const char *actor)
  1147. /* actor is no longer a moron */
  1148. {
  1149. xs *fn = _muted_fn(snac, actor);
  1150. unlink(fn);
  1151. snac_debug(snac, 2, xs_fmt("unmuted %s %s", actor, fn));
  1152. }
  1153. int is_muted(snac *snac, const char *actor)
  1154. /* check if someone is muted */
  1155. {
  1156. xs *fn = _muted_fn(snac, actor);
  1157. return !!(mtime(fn) != 0.0);
  1158. }
  1159. xs_list *muted_list(snac *user)
  1160. /* returns the list (actor URLs) of the muted morons */
  1161. {
  1162. xs_list *l = xs_list_new();
  1163. xs *spec = xs_fmt("%s/muted/" "*", user->basedir);
  1164. xs *files = xs_glob(spec, 0, 0);
  1165. const char *fn;
  1166. xs_list_foreach(files, fn) {
  1167. FILE *f;
  1168. if ((f = fopen(fn, "r")) != NULL) {
  1169. xs *actor = xs_strip_i(xs_readline(f));
  1170. fclose(f);
  1171. l = xs_list_append(l, actor);
  1172. }
  1173. }
  1174. return l;
  1175. }
  1176. /** bookmarking **/
  1177. int is_bookmarked(snac *user, const char *id)
  1178. /* returns true if this note is bookmarked */
  1179. {
  1180. return object_user_cache_in(user, id, "bookmark");
  1181. }
  1182. int bookmark(snac *user, const char *id)
  1183. /* bookmarks a post */
  1184. {
  1185. if (is_bookmarked(user, id))
  1186. return -3;
  1187. return object_user_cache_add(user, id, "bookmark");
  1188. }
  1189. int unbookmark(snac *user, const char *id)
  1190. /* unbookmarks a post */
  1191. {
  1192. return object_user_cache_del(user, id, "bookmark");
  1193. }
  1194. xs_list *bookmark_list(snac *user)
  1195. /* return the lists of bookmarked posts */
  1196. {
  1197. return object_user_cache_list(user, "bookmark", XS_ALL, 1);
  1198. }
  1199. xs_str *bookmark_index_fn(snac *user)
  1200. {
  1201. return object_user_cache_index_fn(user, "bookmark");
  1202. }
  1203. /** pinning **/
  1204. int is_pinned(snac *user, const char *id)
  1205. /* returns true if this note is pinned */
  1206. {
  1207. return object_user_cache_in(user, id, "pinned");
  1208. }
  1209. int is_pinned_by_md5(snac *user, const char *md5)
  1210. {
  1211. return object_user_cache_in_by_md5(user, md5, "pinned");
  1212. }
  1213. int pin(snac *user, const char *id)
  1214. /* pins a message */
  1215. {
  1216. int ret = -2;
  1217. if (xs_startswith(id, user->actor)) {
  1218. if (is_pinned(user, id))
  1219. ret = -3;
  1220. else
  1221. ret = object_user_cache_add(user, id, "pinned");
  1222. }
  1223. return ret;
  1224. }
  1225. int unpin(snac *user, const char *id)
  1226. /* unpin a message */
  1227. {
  1228. return object_user_cache_del(user, id, "pinned");
  1229. }
  1230. xs_list *pinned_list(snac *user)
  1231. /* return the lists of pinned posts */
  1232. {
  1233. return object_user_cache_list(user, "pinned", XS_ALL, 1);
  1234. }
  1235. /** drafts **/
  1236. int is_draft(snac *user, const char *id)
  1237. /* returns true if this note is a draft */
  1238. {
  1239. return object_user_cache_in(user, id, "draft");
  1240. }
  1241. void draft_del(snac *user, const char *id)
  1242. /* delete a message from the draft cache */
  1243. {
  1244. object_user_cache_del(user, id, "draft");
  1245. }
  1246. void draft_add(snac *user, const char *id, const xs_dict *msg)
  1247. /* store the message as a draft */
  1248. {
  1249. /* delete from the index, in case it was already there */
  1250. draft_del(user, id);
  1251. /* overwrite object */
  1252. object_add_ow(id, msg);
  1253. /* [re]add to the index */
  1254. object_user_cache_add(user, id, "draft");
  1255. }
  1256. xs_list *draft_list(snac *user)
  1257. /* return the lists of drafts */
  1258. {
  1259. return object_user_cache_list(user, "draft", XS_ALL, 1);
  1260. }
  1261. /** hiding **/
  1262. xs_str *_hidden_fn(snac *snac, const char *id)
  1263. {
  1264. xs *md5 = xs_md5_hex(id, strlen(id));
  1265. return xs_fmt("%s/hidden/%s", snac->basedir, md5);
  1266. }
  1267. void hide(snac *snac, const char *id)
  1268. /* hides a message tree */
  1269. {
  1270. xs *fn = _hidden_fn(snac, id);
  1271. FILE *f;
  1272. if ((f = fopen(fn, "w")) != NULL) {
  1273. fprintf(f, "%s\n", id);
  1274. fclose(f);
  1275. snac_debug(snac, 2, xs_fmt("hidden %s %s", id, fn));
  1276. /* hide all the children */
  1277. xs *chld = object_children(id);
  1278. char *p;
  1279. const char *v;
  1280. p = chld;
  1281. while (xs_list_iter(&p, &v)) {
  1282. xs *co = NULL;
  1283. /* resolve to get the id */
  1284. if (valid_status(object_get_by_md5(v, &co))) {
  1285. const char *id = xs_dict_get(co, "id");
  1286. if (id != NULL)
  1287. hide(snac, id);
  1288. }
  1289. }
  1290. }
  1291. }
  1292. int is_hidden(snac *snac, const char *id)
  1293. /* check is id is hidden */
  1294. {
  1295. xs *fn = _hidden_fn(snac, id);
  1296. return !!(mtime(fn) != 0.0);
  1297. }
  1298. int actor_add(const char *actor, const xs_dict *msg)
  1299. /* adds an actor */
  1300. {
  1301. return object_add_ow(actor, msg);
  1302. }
  1303. int actor_get(const char *actor, xs_dict **data)
  1304. /* returns an already downloaded actor */
  1305. {
  1306. int status = HTTP_STATUS_OK;
  1307. xs_dict *d = NULL;
  1308. if (xs_startswith(actor, srv_baseurl)) {
  1309. /* it's a (possible) local user */
  1310. xs *l = xs_split(actor, "/");
  1311. const char *uid = xs_list_get(l, -1);
  1312. snac user;
  1313. if (!xs_is_null(uid) && user_open(&user, uid)) {
  1314. if (data)
  1315. *data = msg_actor(&user);
  1316. user_free(&user);
  1317. return HTTP_STATUS_OK;
  1318. }
  1319. else
  1320. return HTTP_STATUS_NOT_FOUND;
  1321. }
  1322. /* read the object */
  1323. if (!valid_status(status = object_get(actor, &d))) {
  1324. d = xs_free(d);
  1325. return status;
  1326. }
  1327. /* if the object is corrupted, discard it */
  1328. if (xs_is_null(xs_dict_get(d, "id")) || xs_is_null(xs_dict_get(d, "type"))) {
  1329. srv_debug(1, xs_fmt("corrupted actor object %s", actor));
  1330. d = xs_free(d);
  1331. return HTTP_STATUS_NOT_FOUND;
  1332. }
  1333. if (data)
  1334. *data = d;
  1335. else
  1336. d = xs_free(d);
  1337. xs *fn = _object_fn(actor);
  1338. double max_time;
  1339. /* maximum time for the actor data to be considered stale */
  1340. max_time = 3600.0 * 36.0;
  1341. if (mtime(fn) + max_time < (double) time(NULL)) {
  1342. /* actor data exists but also stinks */
  1343. status = HTTP_STATUS_RESET_CONTENT; /* "110: Response Is Stale" */
  1344. }
  1345. return status;
  1346. }
  1347. int actor_get_refresh(snac *user, const char *actor, xs_dict **data)
  1348. /* gets an actor and requests a refresh if it's stale */
  1349. {
  1350. int status = actor_get(actor, data);
  1351. if (status == HTTP_STATUS_RESET_CONTENT && user && !xs_startswith(actor, srv_baseurl))
  1352. enqueue_actor_refresh(user, actor, 0);
  1353. return status;
  1354. }
  1355. /** user limiting (announce blocks) **/
  1356. int limited(snac *user, const char *id, int cmd)
  1357. /* announce messages from a followed (0: check, 1: limit; 2: unlimit) */
  1358. {
  1359. int ret = 0;
  1360. xs *dir = xs_fmt("%s/limited", user->basedir);
  1361. xs *md5 = xs_md5_hex(id, strlen(id));
  1362. xs *fn = xs_fmt("%s/%s", dir, md5);
  1363. switch (cmd) {
  1364. case 0: /** check **/
  1365. ret = !!(mtime(fn) > 0.0);
  1366. break;
  1367. case 1: /** limit **/
  1368. mkdirx(dir);
  1369. if (mtime(fn) > 0.0)
  1370. ret = -1;
  1371. else {
  1372. FILE *f;
  1373. if ((f = fopen(fn, "w")) != NULL) {
  1374. fprintf(f, "%s\n", id);
  1375. fclose(f);
  1376. }
  1377. else
  1378. ret = -2;
  1379. }
  1380. break;
  1381. case 2: /** unlimit **/
  1382. if (mtime(fn) > 0.0)
  1383. ret = unlink(fn);
  1384. else
  1385. ret = -1;
  1386. break;
  1387. }
  1388. return ret;
  1389. }
  1390. /** tag indexing **/
  1391. void tag_index(const char *id, const xs_dict *obj)
  1392. /* update the tag indexes for this object */
  1393. {
  1394. const xs_list *tags = xs_dict_get(obj, "tag");
  1395. xs *md5_id = xs_md5_hex(id, strlen(id));
  1396. if (is_msg_public(obj) && xs_type(tags) == XSTYPE_LIST && xs_list_len(tags) > 0) {
  1397. xs *g_tag_dir = xs_fmt("%s/tag", srv_basedir);
  1398. mkdirx(g_tag_dir);
  1399. const xs_dict *v;
  1400. int ct = 0;
  1401. while (xs_list_next(tags, &v, &ct)) {
  1402. const char *type = xs_dict_get(v, "type");
  1403. const char *name = xs_dict_get(v, "name");
  1404. if (!xs_is_null(type) && !xs_is_null(name) && strcmp(type, "Hashtag") == 0) {
  1405. while (*name == '#' || *name == '@')
  1406. name++;
  1407. if (*name == '\0')
  1408. continue;
  1409. name = xs_tolower_i((xs_str *)name);
  1410. xs *md5_tag = xs_md5_hex(name, strlen(name));
  1411. xs *tag_dir = xs_fmt("%s/%c%c", g_tag_dir, md5_tag[0], md5_tag[1]);
  1412. mkdirx(tag_dir);
  1413. xs *g_tag_idx = xs_fmt("%s/%s.idx", tag_dir, md5_tag);
  1414. if (!index_in_md5(g_tag_idx, md5_id))
  1415. index_add_md5(g_tag_idx, md5_id);
  1416. FILE *f;
  1417. xs *g_tag_name = xs_replace(g_tag_idx, ".idx", ".tag");
  1418. if ((f = fopen(g_tag_name, "w")) != NULL) {
  1419. fprintf(f, "%s\n", name);
  1420. fclose(f);
  1421. }
  1422. srv_debug(0, xs_fmt("tagged %s #%s (#%s)", id, name, md5_tag));
  1423. }
  1424. }
  1425. }
  1426. }
  1427. xs_str *tag_fn(const char *tag)
  1428. {
  1429. if (*tag == '#')
  1430. tag++;
  1431. xs *lw_tag = xs_tolower_i(xs_dup(tag));
  1432. xs *md5 = xs_md5_hex(lw_tag, strlen(lw_tag));
  1433. return xs_fmt("%s/tag/%c%c/%s.idx", srv_basedir, md5[0], md5[1], md5);
  1434. }
  1435. xs_list *tag_search(const char *tag, int skip, int show)
  1436. /* returns the list of posts tagged with tag */
  1437. {
  1438. xs *idx = tag_fn(tag);
  1439. return index_list_desc(idx, skip, show);
  1440. }
  1441. /** lists **/
  1442. xs_val *list_maint(snac *user, const char *list, int op)
  1443. /* list maintenance */
  1444. {
  1445. xs_val *l = NULL;
  1446. switch (op) {
  1447. case 0: /** list of lists **/
  1448. {
  1449. FILE *f;
  1450. xs *spec = xs_fmt("%s/list/" "*.id", user->basedir);
  1451. xs *ls = xs_glob(spec, 0, 0);
  1452. int c = 0;
  1453. const char *v;
  1454. l = xs_list_new();
  1455. while (xs_list_next(ls, &v, &c)) {
  1456. if ((f = fopen(v, "r")) != NULL) {
  1457. xs *title = xs_readline(f);
  1458. fclose(f);
  1459. title = xs_strip_i(title);
  1460. xs *v2 = xs_replace(v, ".id", "");
  1461. xs *l2 = xs_split(v2, "/");
  1462. /* return [ list_id, list_title ] */
  1463. l = xs_list_append(l, xs_list_append(xs_list_new(), xs_list_get(l2, -1), title));
  1464. }
  1465. }
  1466. }
  1467. break;
  1468. case 1: /** create new list (list is the name) **/
  1469. {
  1470. xs *lol = list_maint(user, NULL, 0);
  1471. int c = 0;
  1472. const xs_list *v;
  1473. int add = 1;
  1474. /* check if this list name already exists */
  1475. while (xs_list_next(lol, &v, &c)) {
  1476. if (strcmp(xs_list_get(v, 1), list) == 0) {
  1477. add = 0;
  1478. l = xs_dup(xs_list_get(v, 0));
  1479. break;
  1480. }
  1481. }
  1482. if (add) {
  1483. FILE *f;
  1484. xs *dir = xs_fmt("%s/list/", user->basedir);
  1485. l = xs_fmt("%010x", time(NULL));
  1486. mkdirx(dir);
  1487. xs *fn = xs_fmt("%s%s.id", dir, l);
  1488. if ((f = fopen(fn, "w")) != NULL) {
  1489. fprintf(f, "%s\n", list);
  1490. fclose(f);
  1491. }
  1492. }
  1493. }
  1494. break;
  1495. case 2: /** delete list (list is the id) **/
  1496. {
  1497. if (xs_is_hex(list)) {
  1498. xs *fn = xs_fmt("%s/list/%s.id", user->basedir, list);
  1499. unlink(fn);
  1500. fn = xs_replace_i(fn, ".id", ".lst");
  1501. unlink(fn);
  1502. fn = xs_replace_i(fn, ".lst", ".idx");
  1503. unlink(fn);
  1504. fn = xs_str_cat(fn, ".bak");
  1505. unlink(fn);
  1506. }
  1507. }
  1508. break;
  1509. case 3: /** get list name **/
  1510. if (xs_is_hex(list)) {
  1511. FILE *f;
  1512. xs *fn = xs_fmt("%s/list/%s.id", user->basedir, list);
  1513. if ((f = fopen(fn, "r")) != NULL) {
  1514. l = xs_strip_i(xs_readline(f));
  1515. fclose(f);
  1516. }
  1517. }
  1518. break;
  1519. }
  1520. return l;
  1521. }
  1522. xs_str *list_timeline_fn(snac *user, const char *list)
  1523. {
  1524. return xs_fmt("%s/list/%s.idx", user->basedir, list);
  1525. }
  1526. xs_list *list_timeline(snac *user, const char *list, int skip, int show)
  1527. /* returns the timeline of a list */
  1528. {
  1529. xs_list *l = NULL;
  1530. if (!xs_is_hex(list))
  1531. return NULL;
  1532. xs *fn = list_timeline_fn(user, list);
  1533. if (mtime(fn) > 0.0)
  1534. l = index_list_desc(fn, skip, show);
  1535. else
  1536. l = xs_list_new();
  1537. return l;
  1538. }
  1539. xs_val *list_content(snac *user, const char *list, const char *actor_md5, int op)
  1540. /* list content management */
  1541. {
  1542. xs_val *l = NULL;
  1543. if (!xs_is_hex(list))
  1544. return NULL;
  1545. if (actor_md5 != NULL && !xs_is_hex(actor_md5))
  1546. return NULL;
  1547. xs *fn = xs_fmt("%s/list/%s.lst", user->basedir, list);
  1548. switch (op) {
  1549. case 0: /** list content **/
  1550. l = index_list(fn, XS_ALL);
  1551. break;
  1552. case 1: /** append actor to list **/
  1553. if (actor_md5 != NULL) {
  1554. if (!index_in_md5(fn, actor_md5))
  1555. index_add_md5(fn, actor_md5);
  1556. }
  1557. break;
  1558. case 2: /** delete actor from list **/
  1559. if (actor_md5 != NULL)
  1560. index_del_md5(fn, actor_md5);
  1561. break;
  1562. default:
  1563. srv_log(xs_fmt("ERROR: list_content: bad op %d", op));
  1564. break;
  1565. }
  1566. return l;
  1567. }
  1568. void list_distribute(snac *user, const char *who, const xs_dict *post)
  1569. /* distributes the post to all appropriate lists */
  1570. {
  1571. const char *id = xs_dict_get(post, "id");
  1572. /* if who is not set, use the attributedTo in the message */
  1573. if (xs_is_null(who))
  1574. who = get_atto(post);
  1575. if (xs_type(who) == XSTYPE_STRING && xs_type(id) == XSTYPE_STRING) {
  1576. xs *a_md5 = xs_md5_hex(who, strlen(who));
  1577. xs *i_md5 = xs_md5_hex(id, strlen(id));
  1578. xs *spec = xs_fmt("%s/list/" "*.lst", user->basedir);
  1579. xs *ls = xs_glob(spec, 0, 0);
  1580. int c = 0;
  1581. const char *v;
  1582. while (xs_list_next(ls, &v, &c)) {
  1583. /* is the actor in this list? */
  1584. if (index_in_md5(v, a_md5)) {
  1585. /* it is; add post md5 to its timeline */
  1586. xs *idx = xs_replace(v, ".lst", ".idx");
  1587. index_add_md5(idx, i_md5);
  1588. snac_debug(user, 1, xs_fmt("listed post %s in %s", id, idx));
  1589. }
  1590. }
  1591. }
  1592. }
  1593. /** static data **/
  1594. static int _load_raw_file(const char *fn, xs_val **data, int *size,
  1595. const char *inm, xs_str **etag)
  1596. /* loads a cached file */
  1597. {
  1598. int status = HTTP_STATUS_NOT_FOUND;
  1599. if (fn) {
  1600. double tm = mtime(fn);
  1601. if (tm > 0.0) {
  1602. /* file exists; build the etag */
  1603. xs *e = xs_fmt("W/\"snac-%.0lf\"", tm);
  1604. /* if if-none-match is set, check if it's the same */
  1605. if (!xs_is_null(inm) && strcmp(e, inm) == 0) {
  1606. /* client has the newest version */
  1607. status = HTTP_STATUS_NOT_MODIFIED;
  1608. }
  1609. else {
  1610. /* newer or never downloaded; read the full file */
  1611. FILE *f;
  1612. if ((f = fopen(fn, "rb")) != NULL) {
  1613. *size = XS_ALL;
  1614. *data = xs_read(f, size);
  1615. fclose(f);
  1616. status = HTTP_STATUS_OK;
  1617. }
  1618. }
  1619. /* if caller wants the etag, return it */
  1620. if (etag != NULL)
  1621. *etag = xs_dup(e);
  1622. srv_debug(1, xs_fmt("_load_raw_file(): %s %d", fn, status));
  1623. }
  1624. }
  1625. return status;
  1626. }
  1627. xs_str *_static_fn(snac *snac, const char *id)
  1628. /* gets the filename for a static file */
  1629. {
  1630. if (strchr(id, '/'))
  1631. return NULL;
  1632. else
  1633. return xs_fmt("%s/static/%s", snac->basedir, id);
  1634. }
  1635. int static_get(snac *snac, const char *id, xs_val **data, int *size,
  1636. const char *inm, xs_str **etag)
  1637. /* returns static content */
  1638. {
  1639. xs *fn = _static_fn(snac, id);
  1640. return _load_raw_file(fn, data, size, inm, etag);
  1641. }
  1642. void static_put(snac *snac, const char *id, const char *data, int size)
  1643. /* writes status content */
  1644. {
  1645. xs *fn = _static_fn(snac, id);
  1646. FILE *f;
  1647. if (fn && (f = fopen(fn, "wb")) != NULL) {
  1648. fwrite(data, size, 1, f);
  1649. fclose(f);
  1650. }
  1651. }
  1652. void static_put_meta(snac *snac, const char *id, const char *str)
  1653. /* puts metadata (i.e. a media description string) to id */
  1654. {
  1655. xs *fn = _static_fn(snac, id);
  1656. if (fn) {
  1657. fn = xs_str_cat(fn, ".txt");
  1658. FILE *f;
  1659. if ((f = fopen(fn, "w")) != NULL) {
  1660. fprintf(f, "%s\n", str);
  1661. fclose(f);
  1662. }
  1663. }
  1664. }
  1665. xs_str *static_get_meta(snac *snac, const char *id)
  1666. /* gets metadata from a media */
  1667. {
  1668. xs *fn = _static_fn(snac, id);
  1669. xs_str *r = NULL;
  1670. if (fn) {
  1671. fn = xs_str_cat(fn, ".txt");
  1672. FILE *f;
  1673. if ((f = fopen(fn, "r")) != NULL) {
  1674. r = xs_strip_i(xs_readline(f));
  1675. fclose(f);
  1676. }
  1677. }
  1678. else
  1679. r = xs_str_new("");
  1680. return r;
  1681. }
  1682. /** history **/
  1683. xs_str *_history_fn(snac *snac, const char *id)
  1684. /* gets the filename for the history */
  1685. {
  1686. if (strchr(id, '/'))
  1687. return NULL;
  1688. else
  1689. return xs_fmt("%s/history/%s", snac->basedir, id);
  1690. }
  1691. double history_mtime(snac *snac, const char *id)
  1692. {
  1693. double t = 0.0;
  1694. xs *fn = _history_fn(snac, id);
  1695. if (fn != NULL)
  1696. t = mtime(fn);
  1697. return t;
  1698. }
  1699. void history_add(snac *snac, const char *id, const char *content, int size,
  1700. xs_str **etag)
  1701. /* adds something to the history */
  1702. {
  1703. xs *fn = _history_fn(snac, id);
  1704. FILE *f;
  1705. if (fn && (f = fopen(fn, "w")) != NULL) {
  1706. fwrite(content, size, 1, f);
  1707. fclose(f);
  1708. if (etag) {
  1709. double tm = mtime(fn);
  1710. *etag = xs_fmt("W/\"snac-%.0lf\"", tm);
  1711. }
  1712. }
  1713. }
  1714. int history_get(snac *snac, const char *id, xs_str **content, int *size,
  1715. const char *inm, xs_str **etag)
  1716. {
  1717. xs *fn = _history_fn(snac, id);
  1718. return _load_raw_file(fn, content, size, inm, etag);
  1719. }
  1720. int history_del(snac *snac, const char *id)
  1721. {
  1722. xs *fn = _history_fn(snac, id);
  1723. if (fn)
  1724. return unlink(fn);
  1725. else
  1726. return -1;
  1727. }
  1728. xs_list *history_list(snac *snac)
  1729. {
  1730. xs *spec = xs_fmt("%s/history/" "*.html", snac->basedir);
  1731. return xs_glob(spec, 1, 1);
  1732. }
  1733. void lastlog_write(snac *snac, const char *source)
  1734. /* writes the last time the user logged in */
  1735. {
  1736. xs *fn = xs_fmt("%s/lastlog.txt", snac->basedir);
  1737. FILE *f;
  1738. if ((f = fopen(fn, "w")) != NULL) {
  1739. fprintf(f, "%lf %s\n", ftime(), source);
  1740. fclose(f);
  1741. }
  1742. }
  1743. /** inbox collection **/
  1744. void inbox_add(const char *inbox)
  1745. /* collects a shared inbox */
  1746. {
  1747. /* don't collect ourselves */
  1748. if (xs_startswith(inbox, srv_baseurl))
  1749. return;
  1750. xs *md5 = xs_md5_hex(inbox, strlen(inbox));
  1751. xs *fn = xs_fmt("%s/inbox/%s", srv_basedir, md5);
  1752. FILE *f;
  1753. if ((f = fopen(fn, "w")) != NULL) {
  1754. fprintf(f, "%s\n", inbox);
  1755. fclose(f);
  1756. }
  1757. }
  1758. void inbox_add_by_actor(const xs_dict *actor)
  1759. /* collects an actor's shared inbox, if it has one */
  1760. {
  1761. const char *v;
  1762. if (!xs_is_null(v = xs_dict_get(actor, "endpoints")) &&
  1763. !xs_is_null(v = xs_dict_get(v, "sharedInbox"))) {
  1764. /* only collect this inbox if its instance is not blocked */
  1765. if (!is_instance_blocked(v))
  1766. inbox_add(v);
  1767. }
  1768. }
  1769. xs_list *inbox_list(void)
  1770. /* returns the collected inboxes as a list */
  1771. {
  1772. xs_list *ibl = xs_list_new();
  1773. xs *spec = xs_fmt("%s/inbox/" "*", srv_basedir);
  1774. xs *files = xs_glob(spec, 0, 0);
  1775. xs_list *p = files;
  1776. const xs_val *v;
  1777. while (xs_list_iter(&p, &v)) {
  1778. FILE *f;
  1779. if ((f = fopen(v, "r")) != NULL) {
  1780. xs *line = xs_readline(f);
  1781. if (line) {
  1782. line = xs_strip_i(line);
  1783. ibl = xs_list_append(ibl, line);
  1784. }
  1785. fclose(f);
  1786. }
  1787. }
  1788. return ibl;
  1789. }
  1790. /** instance-wide operations **/
  1791. xs_str *_instance_block_fn(const char *instance)
  1792. {
  1793. xs *s = xs_replace(instance, "http:/" "/", "");
  1794. xs *s1 = xs_replace(s, "https:/" "/", "");
  1795. xs *l = xs_split(s1, "/");
  1796. const char *p = xs_list_get(l, 0);
  1797. xs *md5 = xs_md5_hex(p, strlen(p));
  1798. return xs_fmt("%s/block/%s", srv_basedir, md5);
  1799. }
  1800. int is_instance_blocked(const char *instance)
  1801. {
  1802. xs *fn = _instance_block_fn(instance);
  1803. return !!(mtime(fn) != 0.0);
  1804. }
  1805. int instance_block(const char *instance)
  1806. /* blocks a full instance */
  1807. {
  1808. int ret;
  1809. /* create the subdir */
  1810. xs *dir = xs_fmt("%s/block/", srv_basedir);
  1811. mkdirx(dir);
  1812. if (!is_instance_blocked(instance)) {
  1813. xs *fn = _instance_block_fn(instance);
  1814. FILE *f;
  1815. if ((f = fopen(fn, "w")) != NULL) {
  1816. fprintf(f, "%s\n", instance);
  1817. fclose(f);
  1818. ret = 0;
  1819. }
  1820. else
  1821. ret = -1;
  1822. }
  1823. else
  1824. ret = -2;
  1825. return ret;
  1826. }
  1827. int instance_unblock(const char *instance)
  1828. /* unblocks a full instance */
  1829. {
  1830. int ret;
  1831. if (is_instance_blocked(instance)) {
  1832. xs *fn = _instance_block_fn(instance);
  1833. ret = unlink(fn);
  1834. }
  1835. else
  1836. ret = -2;
  1837. return ret;
  1838. }
  1839. /** operations by content **/
  1840. int content_match(const char *file, const xs_dict *msg)
  1841. /* checks if a message's content matches any of the regexes in file */
  1842. /* file format: one regex per line */
  1843. {
  1844. xs *fn = xs_fmt("%s/%s", srv_basedir, file);
  1845. FILE *f;
  1846. int r = 0;
  1847. const char *v = xs_dict_get(msg, "content");
  1848. if (xs_type(v) == XSTYPE_STRING && *v) {
  1849. if ((f = fopen(fn, "r")) != NULL) {
  1850. srv_debug(1, xs_fmt("content_match: loading regexes from %s", fn));
  1851. /* massage content (strip HTML tags, etc.) */
  1852. xs *c = xs_regex_replace(v, "<[^>]+>", " ");
  1853. c = xs_regex_replace_i(c, " {2,}", " ");
  1854. c = xs_tolower_i(c);
  1855. while (!r && !feof(f)) {
  1856. xs *rx = xs_strip_i(xs_readline(f));
  1857. if (*rx && xs_regex_match(c, rx)) {
  1858. srv_debug(1, xs_fmt("content_match: match for '%s'", rx));
  1859. r = 1;
  1860. }
  1861. }
  1862. fclose(f);
  1863. }
  1864. }
  1865. return r;
  1866. }
  1867. xs_list *content_search(snac *user, const char *regex,
  1868. int priv, int skip, int show, int max_secs, int *timeout)
  1869. /* returns a list of posts which content matches the regex */
  1870. {
  1871. if (regex == NULL || *regex == '\0')
  1872. return xs_list_new();
  1873. xs *i_regex = xs_utf8_to_lower(regex);
  1874. xs_set seen;
  1875. xs_set_init(&seen);
  1876. if (max_secs == 0)
  1877. max_secs = 3;
  1878. time_t t = time(NULL) + max_secs;
  1879. *timeout = 0;
  1880. /* iterate all timelines simultaneously */
  1881. xs_list *tls[3] = {0};
  1882. const char *md5s[3] = {0};
  1883. int c[3] = {0};
  1884. tls[0] = timeline_simple_list(user, "public", 0, XS_ALL); /* public */
  1885. tls[1] = timeline_instance_list(0, XS_ALL); /* instance */
  1886. tls[2] = priv ? timeline_simple_list(user, "private", 0, XS_ALL) : xs_list_new(); /* private or none */
  1887. /* first positioning */
  1888. for (int n = 0; n < 3; n++)
  1889. xs_list_next(tls[n], &md5s[n], &c[n]);
  1890. show += skip;
  1891. while (show > 0) {
  1892. /* timeout? */
  1893. if (time(NULL) > t) {
  1894. *timeout = 1;
  1895. break;
  1896. }
  1897. /* find the newest post */
  1898. int newest = -1;
  1899. double mtime = 0.0;
  1900. for (int n = 0; n < 3; n++) {
  1901. if (md5s[n] != NULL) {
  1902. xs *fn = _object_fn_by_md5(md5s[n], "content_search");
  1903. double mt = mtime(fn);
  1904. if (mt > mtime) {
  1905. newest = n;
  1906. mtime = mt;
  1907. }
  1908. }
  1909. }
  1910. if (newest == -1)
  1911. break;
  1912. const char *md5 = md5s[newest];
  1913. /* advance the chosen timeline */
  1914. if (!xs_list_next(tls[newest], &md5s[newest], &c[newest]))
  1915. md5s[newest] = NULL;
  1916. xs *post = NULL;
  1917. if (!valid_status(object_get_by_md5(md5, &post)))
  1918. continue;
  1919. if (!xs_match(xs_dict_get_def(post, "type", "-"), POSTLIKE_OBJECT_TYPE))
  1920. continue;
  1921. const char *id = xs_dict_get(post, "id");
  1922. if (id == NULL || is_hidden(user, id))
  1923. continue;
  1924. xs *c = xs_str_new(NULL);
  1925. const char *content = xs_dict_get(post, "content");
  1926. const char *name = xs_dict_get(post, "name");
  1927. if (!xs_is_null(content))
  1928. c = xs_str_cat(c, content);
  1929. if (!xs_is_null(name))
  1930. c = xs_str_cat(c, " ", name);
  1931. /* add alt-texts from attachments */
  1932. const xs_list *atts = xs_dict_get(post, "attachment");
  1933. int tc = 0;
  1934. const xs_dict *att;
  1935. while (xs_list_next(atts, &att, &tc)) {
  1936. const char *name = xs_dict_get(att, "name");
  1937. if (name != NULL)
  1938. c = xs_str_cat(c, " ", name);
  1939. }
  1940. /* strip HTML */
  1941. c = xs_regex_replace_i(c, "<[^>]+>", " ");
  1942. c = xs_regex_replace_i(c, " {2,}", " ");
  1943. /* convert to lowercase */
  1944. xs *lc = xs_utf8_to_lower(c);
  1945. /* apply regex */
  1946. if (xs_regex_match(lc, i_regex)) {
  1947. if (xs_set_add(&seen, md5) == 1)
  1948. show--;
  1949. }
  1950. }
  1951. xs_list *r = xs_set_result(&seen);
  1952. if (skip) {
  1953. /* BAD */
  1954. while (skip--) {
  1955. r = xs_list_del(r, 0);
  1956. }
  1957. }
  1958. xs_free(tls[0]);
  1959. xs_free(tls[1]);
  1960. xs_free(tls[2]);
  1961. return r;
  1962. }
  1963. /** notifications **/
  1964. xs_str *notify_check_time(snac *snac, int reset)
  1965. /* gets or resets the latest notification check time */
  1966. {
  1967. xs_str *t = NULL;
  1968. xs *fn = xs_fmt("%s/notifydate.txt", snac->basedir);
  1969. FILE *f;
  1970. if (reset) {
  1971. if ((f = fopen(fn, "w")) != NULL) {
  1972. t = tid(0);
  1973. fprintf(f, "%s\n", t);
  1974. fclose(f);
  1975. }
  1976. }
  1977. else {
  1978. if ((f = fopen(fn, "r")) != NULL) {
  1979. t = xs_readline(f);
  1980. fclose(f);
  1981. }
  1982. else
  1983. /* never set before */
  1984. t = xs_fmt("%16.6f", 0.0);
  1985. }
  1986. return t;
  1987. }
  1988. void notify_add(snac *snac, const char *type, const char *utype,
  1989. const char *actor, const char *objid, const xs_dict *msg)
  1990. /* adds a new notification */
  1991. {
  1992. xs *ntid = tid(0);
  1993. xs *fn = xs_fmt("%s/notify/", snac->basedir);
  1994. xs *date = xs_str_utctime(0, ISO_DATE_SPEC);
  1995. FILE *f;
  1996. /* create the directory */
  1997. mkdirx(fn);
  1998. fn = xs_str_cat(fn, ntid);
  1999. fn = xs_str_cat(fn, ".json");
  2000. xs *noti = xs_dict_new();
  2001. noti = xs_dict_append(noti, "id", ntid);
  2002. noti = xs_dict_append(noti, "type", type);
  2003. noti = xs_dict_append(noti, "utype", utype);
  2004. noti = xs_dict_append(noti, "actor", actor);
  2005. noti = xs_dict_append(noti, "date", date);
  2006. noti = xs_dict_append(noti, "msg", msg);
  2007. if (!xs_is_null(objid))
  2008. noti = xs_dict_append(noti, "objid", objid);
  2009. if ((f = fopen(fn, "w")) != NULL) {
  2010. xs_json_dump(noti, 4, f);
  2011. fclose(f);
  2012. }
  2013. /* add it to the index if it already exists */
  2014. xs *idx = xs_fmt("%s/notify.idx", snac->basedir);
  2015. if (mtime(idx) != 0.0) {
  2016. pthread_mutex_lock(&data_mutex);
  2017. if ((f = fopen(idx, "a")) != NULL) {
  2018. fprintf(f, "%-32s\n", ntid);
  2019. fclose(f);
  2020. }
  2021. pthread_mutex_unlock(&data_mutex);
  2022. }
  2023. }
  2024. xs_dict *notify_get(snac *snac, const char *id)
  2025. /* gets a notification */
  2026. {
  2027. /* base file */
  2028. xs *fn = xs_fmt("%s/notify/%s", snac->basedir, id);
  2029. /* strip spaces and add extension */
  2030. fn = xs_strip_i(fn);
  2031. fn = xs_str_cat(fn, ".json");
  2032. FILE *f;
  2033. xs_dict *out = NULL;
  2034. if ((f = fopen(fn, "r")) != NULL) {
  2035. out = xs_json_load(f);
  2036. fclose(f);
  2037. }
  2038. return out;
  2039. }
  2040. xs_list *notify_list(snac *snac, int skip, int show)
  2041. /* returns a list of notification ids */
  2042. {
  2043. xs *idx = xs_fmt("%s/notify.idx", snac->basedir);
  2044. if (mtime(idx) == 0.0) {
  2045. /* create the index from scratch */
  2046. FILE *f;
  2047. pthread_mutex_lock(&data_mutex);
  2048. if ((f = fopen(idx, "w")) != NULL) {
  2049. xs *spec = xs_fmt("%s/notify/" "*.json", snac->basedir);
  2050. xs *lst = xs_glob(spec, 1, 0);
  2051. xs_list *p = lst;
  2052. const char *v;
  2053. while (xs_list_iter(&p, &v)) {
  2054. char *p = strrchr(v, '.');
  2055. if (p) {
  2056. *p = '\0';
  2057. fprintf(f, "%-32s\n", v);
  2058. }
  2059. }
  2060. fclose(f);
  2061. }
  2062. pthread_mutex_unlock(&data_mutex);
  2063. }
  2064. return index_list_desc(idx, skip, show);
  2065. }
  2066. int notify_new_num(snac *snac)
  2067. /* counts the number of new notifications */
  2068. {
  2069. xs *t = notify_check_time(snac, 0);
  2070. xs *lst = notify_list(snac, 0, XS_ALL);
  2071. int cnt = 0;
  2072. xs_list *p = lst;
  2073. const xs_str *v;
  2074. while (xs_list_iter(&p, &v)) {
  2075. xs *id = xs_strip_i(xs_dup(v));
  2076. /* old? count no more */
  2077. if (strcmp(id, t) < 0)
  2078. break;
  2079. cnt++;
  2080. }
  2081. return cnt;
  2082. }
  2083. void notify_clear(snac *snac)
  2084. /* clears all notifications */
  2085. {
  2086. xs *spec = xs_fmt("%s/notify/" "*", snac->basedir);
  2087. xs *lst = xs_glob(spec, 0, 0);
  2088. xs_list *p = lst;
  2089. const xs_str *v;
  2090. while (xs_list_iter(&p, &v))
  2091. unlink(v);
  2092. xs *idx = xs_fmt("%s/notify.idx", snac->basedir);
  2093. if (mtime(idx) != 0.0) {
  2094. pthread_mutex_lock(&data_mutex);
  2095. truncate(idx, 0);
  2096. pthread_mutex_unlock(&data_mutex);
  2097. }
  2098. }
  2099. /** the queue **/
  2100. static xs_dict *_enqueue_put(const char *fn, xs_dict *msg)
  2101. /* writes safely to the queue */
  2102. {
  2103. xs *tfn = xs_fmt("%s.tmp", fn);
  2104. FILE *f;
  2105. if ((f = fopen(tfn, "w")) != NULL) {
  2106. xs_json_dump(msg, 4, f);
  2107. fclose(f);
  2108. rename(tfn, fn);
  2109. }
  2110. return msg;
  2111. }
  2112. static xs_dict *_new_qmsg(const char *type, const xs_val *msg, int retries)
  2113. /* creates a queue message */
  2114. {
  2115. int qrt = xs_number_get(xs_dict_get(srv_config, "queue_retry_minutes"));
  2116. xs *ntid = tid(retries * 60 * qrt);
  2117. xs *rn = xs_number_new(retries);
  2118. xs_dict *qmsg = xs_dict_new();
  2119. qmsg = xs_dict_append(qmsg, "type", type);
  2120. qmsg = xs_dict_append(qmsg, "message", msg);
  2121. qmsg = xs_dict_append(qmsg, "retries", rn);
  2122. qmsg = xs_dict_append(qmsg, "ntid", ntid);
  2123. return qmsg;
  2124. }
  2125. void enqueue_input(snac *snac, const xs_dict *msg, const xs_dict *req, int retries)
  2126. /* enqueues an input message */
  2127. {
  2128. xs *qmsg = _new_qmsg("input", msg, retries);
  2129. const char *ntid = xs_dict_get(qmsg, "ntid");
  2130. xs *fn = xs_fmt("%s/queue/%s.json", snac->basedir, ntid);
  2131. qmsg = xs_dict_append(qmsg, "req", req);
  2132. qmsg = _enqueue_put(fn, qmsg);
  2133. snac_debug(snac, 1, xs_fmt("enqueue_input %s", xs_dict_get(msg, "id")));
  2134. }
  2135. void enqueue_shared_input(const xs_dict *msg, const xs_dict *req, int retries)
  2136. /* enqueues an input message from the shared input */
  2137. {
  2138. xs *qmsg = _new_qmsg("input", msg, retries);
  2139. const char *ntid = xs_dict_get(qmsg, "ntid");
  2140. xs *fn = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
  2141. qmsg = xs_dict_append(qmsg, "req", req);
  2142. qmsg = _enqueue_put(fn, qmsg);
  2143. srv_debug(1, xs_fmt("enqueue_shared_input %s", xs_dict_get(msg, "id")));
  2144. }
  2145. void enqueue_output_raw(const char *keyid, const char *seckey,
  2146. const xs_dict *msg, const xs_str *inbox,
  2147. int retries, int p_status)
  2148. /* enqueues an output message to an inbox */
  2149. {
  2150. xs *qmsg = _new_qmsg("output", msg, retries);
  2151. const char *ntid = xs_dict_get(qmsg, "ntid");
  2152. xs *fn = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
  2153. xs *ns = xs_number_new(p_status);
  2154. qmsg = xs_dict_append(qmsg, "p_status", ns);
  2155. qmsg = xs_dict_append(qmsg, "inbox", inbox);
  2156. qmsg = xs_dict_append(qmsg, "keyid", keyid);
  2157. qmsg = xs_dict_append(qmsg, "seckey", seckey);
  2158. /* if it's to be sent right now, bypass the disk queue and post the job */
  2159. if (retries == 0 && p_state != NULL)
  2160. job_post(qmsg, 0);
  2161. else {
  2162. qmsg = _enqueue_put(fn, qmsg);
  2163. srv_debug(1, xs_fmt("enqueue_output %s %s %d", inbox, fn, retries));
  2164. }
  2165. }
  2166. void enqueue_output(snac *snac, const xs_dict *msg,
  2167. const xs_str *inbox, int retries, int p_status)
  2168. /* enqueues an output message to an inbox */
  2169. {
  2170. if (xs_startswith(inbox, snac->actor)) {
  2171. snac_debug(snac, 1, xs_str_new("refusing enqueue to myself"));
  2172. return;
  2173. }
  2174. const char *seckey = xs_dict_get(snac->key, "secret");
  2175. enqueue_output_raw(snac->actor, seckey, msg, inbox, retries, p_status);
  2176. }
  2177. void enqueue_output_by_actor(snac *snac, const xs_dict *msg,
  2178. const xs_str *actor, int retries)
  2179. /* enqueues an output message for an actor */
  2180. {
  2181. xs *inbox = get_actor_inbox(actor, 1);
  2182. if (!xs_is_null(inbox))
  2183. enqueue_output(snac, msg, inbox, retries, 0);
  2184. else
  2185. snac_log(snac, xs_fmt("enqueue_output_by_actor cannot get inbox %s", actor));
  2186. }
  2187. void enqueue_email(const xs_str *msg, int retries)
  2188. /* enqueues an email message to be sent */
  2189. {
  2190. xs *qmsg = _new_qmsg("email", msg, retries);
  2191. const char *ntid = xs_dict_get(qmsg, "ntid");
  2192. xs *fn = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
  2193. qmsg = _enqueue_put(fn, qmsg);
  2194. srv_debug(1, xs_fmt("enqueue_email %d", retries));
  2195. }
  2196. void enqueue_telegram(const xs_str *msg, const char *bot, const char *chat_id)
  2197. /* enqueues a message to be sent via Telegram */
  2198. {
  2199. xs *qmsg = _new_qmsg("telegram", msg, 0);
  2200. const char *ntid = xs_dict_get(qmsg, "ntid");
  2201. xs *fn = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
  2202. qmsg = xs_dict_append(qmsg, "bot", bot);
  2203. qmsg = xs_dict_append(qmsg, "chat_id", chat_id);
  2204. qmsg = _enqueue_put(fn, qmsg);
  2205. srv_debug(1, xs_fmt("enqueue_telegram %s %s", bot, chat_id));
  2206. }
  2207. void enqueue_ntfy(const xs_str *msg, const char *ntfy_server, const char *ntfy_token)
  2208. /* enqueues a message to be sent via ntfy */
  2209. {
  2210. xs *qmsg = _new_qmsg("ntfy", msg, 0);
  2211. const char *ntid = xs_dict_get(qmsg, "ntid");
  2212. xs *fn = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
  2213. qmsg = xs_dict_append(qmsg, "ntfy_server", ntfy_server);
  2214. qmsg = xs_dict_append(qmsg, "ntfy_token", ntfy_token);
  2215. qmsg = _enqueue_put(fn, qmsg);
  2216. srv_debug(1, xs_fmt("enqueue_ntfy %s %s", ntfy_server, ntfy_token));
  2217. }
  2218. void enqueue_message(snac *snac, const xs_dict *msg)
  2219. /* enqueues an output message */
  2220. {
  2221. xs *qmsg = _new_qmsg("message", msg, 0);
  2222. const char *ntid = xs_dict_get(qmsg, "ntid");
  2223. xs *fn = xs_fmt("%s/queue/%s.json", snac->basedir, ntid);
  2224. qmsg = _enqueue_put(fn, qmsg);
  2225. snac_debug(snac, 0, xs_fmt("enqueue_message %s", xs_dict_get(msg, "id")));
  2226. }
  2227. void enqueue_close_question(snac *user, const char *id, int end_secs)
  2228. /* enqueues the closing of a question */
  2229. {
  2230. xs *qmsg = _new_qmsg("close_question", id, 0);
  2231. xs *ntid = tid(end_secs);
  2232. xs *fn = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
  2233. qmsg = xs_dict_set(qmsg, "ntid", ntid);
  2234. qmsg = _enqueue_put(fn, qmsg);
  2235. snac_debug(user, 0, xs_fmt("enqueue_close_question %s", id));
  2236. }
  2237. void enqueue_object_request(snac *user, const char *id, int forward_secs)
  2238. /* enqueues the request of an object in the future */
  2239. {
  2240. xs *qmsg = _new_qmsg("object_request", id, 0);
  2241. xs *ntid = tid(forward_secs);
  2242. xs *fn = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
  2243. qmsg = xs_dict_set(qmsg, "ntid", ntid);
  2244. qmsg = _enqueue_put(fn, qmsg);
  2245. snac_debug(user, 0, xs_fmt("enqueue_object_request %s %d", id, forward_secs));
  2246. }
  2247. void enqueue_verify_links(snac *user)
  2248. /* enqueues a link verification */
  2249. {
  2250. xs *qmsg = _new_qmsg("verify_links", "", 0);
  2251. const char *ntid = xs_dict_get(qmsg, "ntid");
  2252. xs *fn = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
  2253. qmsg = _enqueue_put(fn, qmsg);
  2254. snac_debug(user, 1, xs_fmt("enqueue_verify_links %s", user->actor));
  2255. }
  2256. void enqueue_actor_refresh(snac *user, const char *actor, int forward_secs)
  2257. /* enqueues an actor refresh */
  2258. {
  2259. xs *qmsg = _new_qmsg("actor_refresh", "", 0);
  2260. xs *ntid = tid(forward_secs);
  2261. xs *fn = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
  2262. qmsg = xs_dict_set(qmsg, "ntid", ntid);
  2263. qmsg = xs_dict_append(qmsg, "actor", actor);
  2264. qmsg = _enqueue_put(fn, qmsg);
  2265. snac_debug(user, 1, xs_fmt("enqueue_actor_refresh %s", actor));
  2266. }
  2267. int was_question_voted(snac *user, const char *id)
  2268. /* returns true if the user voted in this poll */
  2269. {
  2270. xs *children = object_children(id);
  2271. int voted = 0;
  2272. xs_list *p;
  2273. const xs_str *md5;
  2274. p = children;
  2275. while (xs_list_iter(&p, &md5)) {
  2276. xs *obj = NULL;
  2277. if (valid_status(object_get_by_md5(md5, &obj))) {
  2278. const char *atto = get_atto(obj);
  2279. if (atto && strcmp(atto, user->actor) == 0 &&
  2280. !xs_is_null(xs_dict_get(obj, "name"))) {
  2281. voted = 1;
  2282. break;
  2283. }
  2284. }
  2285. }
  2286. return voted;
  2287. }
  2288. xs_list *user_queue(snac *snac)
  2289. /* returns a list with filenames that can be dequeued */
  2290. {
  2291. xs *spec = xs_fmt("%s/queue/" "*.json", snac->basedir);
  2292. xs_list *list = xs_list_new();
  2293. time_t t = time(NULL);
  2294. xs_list *p;
  2295. const xs_val *v;
  2296. xs *fns = xs_glob(spec, 0, 0);
  2297. p = fns;
  2298. while (xs_list_iter(&p, &v)) {
  2299. /* get the retry time from the basename */
  2300. char *bn = strrchr(v, '/');
  2301. time_t t2 = atol(bn + 1);
  2302. if (t2 > t)
  2303. snac_debug(snac, 2, xs_fmt("user_queue not yet time for %s [%ld]", v, t));
  2304. else {
  2305. list = xs_list_append(list, v);
  2306. snac_debug(snac, 2, xs_fmt("user_queue ready for %s", v));
  2307. }
  2308. }
  2309. return list;
  2310. }
  2311. xs_list *queue(void)
  2312. /* returns a list with filenames that can be dequeued */
  2313. {
  2314. xs *spec = xs_fmt("%s/queue/" "*.json", srv_basedir);
  2315. xs_list *list = xs_list_new();
  2316. time_t t = time(NULL);
  2317. xs_list *p;
  2318. const xs_val *v;
  2319. xs *fns = xs_glob(spec, 0, 0);
  2320. p = fns;
  2321. while (xs_list_iter(&p, &v)) {
  2322. /* get the retry time from the basename */
  2323. char *bn = strrchr(v, '/');
  2324. time_t t2 = atol(bn + 1);
  2325. if (t2 > t)
  2326. srv_debug(2, xs_fmt("queue not yet time for %s [%ld]", v, t));
  2327. else {
  2328. list = xs_list_append(list, v);
  2329. srv_debug(2, xs_fmt("queue ready for %s", v));
  2330. }
  2331. }
  2332. return list;
  2333. }
  2334. xs_dict *queue_get(const char *fn)
  2335. /* gets a file from a queue */
  2336. {
  2337. FILE *f;
  2338. xs_dict *obj = NULL;
  2339. if ((f = fopen(fn, "r")) != NULL) {
  2340. obj = xs_json_load(f);
  2341. fclose(f);
  2342. }
  2343. return obj;
  2344. }
  2345. xs_dict *dequeue(const char *fn)
  2346. /* dequeues a message */
  2347. {
  2348. xs_dict *obj = queue_get(fn);
  2349. unlink(fn);
  2350. return obj;
  2351. }
  2352. /** the purge **/
  2353. static int _purge_file(const char *fn, time_t mt)
  2354. /* purge fn if it's older than days */
  2355. {
  2356. int ret = 0;
  2357. if (mtime(fn) < mt) {
  2358. /* older than the minimum time: delete it */
  2359. unlink(fn);
  2360. srv_debug(2, xs_fmt("purged %s", fn));
  2361. ret = 1;
  2362. }
  2363. return ret;
  2364. }
  2365. static void _purge_dir(const char *dir, int days)
  2366. /* purges all files in a directory older than days */
  2367. {
  2368. int cnt = 0;
  2369. if (days) {
  2370. time_t mt = time(NULL) - days * 24 * 3600;
  2371. xs *spec = xs_fmt("%s/" "*", dir);
  2372. xs *list = xs_glob(spec, 0, 0);
  2373. xs_list *p;
  2374. const xs_str *v;
  2375. p = list;
  2376. while (xs_list_iter(&p, &v))
  2377. cnt += _purge_file(v, mt);
  2378. srv_debug(1, xs_fmt("purge: %s %d", dir, cnt));
  2379. }
  2380. }
  2381. static void _purge_user_subdir(snac *snac, const char *subdir, int days)
  2382. /* purges all files in a user subdir older than days */
  2383. {
  2384. xs *u_subdir = xs_fmt("%s/%s", snac->basedir, subdir);
  2385. _purge_dir(u_subdir, days);
  2386. }
  2387. void purge_server(void)
  2388. /* purge global server data */
  2389. {
  2390. xs *spec = xs_fmt("%s/object/??", srv_basedir);
  2391. xs *dirs = xs_glob(spec, 0, 0);
  2392. xs_list *p;
  2393. const xs_str *v;
  2394. int cnt = 0;
  2395. int icnt = 0;
  2396. time_t mt = time(NULL) - 7 * 24 * 3600;
  2397. p = dirs;
  2398. while (xs_list_iter(&p, &v)) {
  2399. xs_list *p2;
  2400. const xs_str *v2;
  2401. {
  2402. xs *spec2 = xs_fmt("%s/" "*.json", v);
  2403. xs *files = xs_glob(spec2, 0, 0);
  2404. p2 = files;
  2405. while (xs_list_iter(&p2, &v2)) {
  2406. int n_link;
  2407. /* old and with no hard links? */
  2408. if (mtime_nl(v2, &n_link) < mt && n_link < 2) {
  2409. xs *s1 = xs_replace(v2, ".json", "");
  2410. xs *l = xs_split(s1, "/");
  2411. const char *md5 = xs_list_get(l, -1);
  2412. object_del_by_md5(md5);
  2413. cnt++;
  2414. }
  2415. }
  2416. }
  2417. {
  2418. /* look for stray indexes */
  2419. xs *speci = xs_fmt("%s/" "*_?.idx", v);
  2420. xs *idxfs = xs_glob(speci, 0, 0);
  2421. p2 = idxfs;
  2422. while (xs_list_iter(&p2, &v2)) {
  2423. /* old enough to consider? */
  2424. if (mtime(v2) < mt) {
  2425. /* check if the indexed object is here */
  2426. xs *o = xs_dup(v2);
  2427. char *ext = strchr(o, '_');
  2428. if (ext) {
  2429. *ext = '\0';
  2430. o = xs_str_cat(o, ".json");
  2431. if (mtime(o) == 0.0) {
  2432. /* delete */
  2433. unlink(v2);
  2434. srv_debug(1, xs_fmt("purged %s", v2));
  2435. icnt++;
  2436. }
  2437. }
  2438. }
  2439. }
  2440. /* delete index backups */
  2441. xs *specb = xs_fmt("%s/" "*.bak", v);
  2442. xs *bakfs = xs_glob(specb, 0, 0);
  2443. p2 = bakfs;
  2444. while (xs_list_iter(&p2, &v2)) {
  2445. unlink(v2);
  2446. srv_debug(1, xs_fmt("purged %s", v2));
  2447. }
  2448. }
  2449. }
  2450. /* purge collected inboxes */
  2451. xs *ib_dir = xs_fmt("%s/inbox", srv_basedir);
  2452. _purge_dir(ib_dir, 7);
  2453. /* purge the instance timeline */
  2454. xs *itl_fn = xs_fmt("%s/public.idx", srv_basedir);
  2455. int itl_gc = index_gc(itl_fn);
  2456. /* purge tag indexes */
  2457. xs *tag_spec = xs_fmt("%s/tag/??", srv_basedir);
  2458. xs *tag_dirs = xs_glob(tag_spec, 0, 0);
  2459. p = tag_dirs;
  2460. int tag_gc = 0;
  2461. while (xs_list_iter(&p, &v)) {
  2462. xs *spec2 = xs_fmt("%s/" "*.idx", v);
  2463. xs *files = xs_glob(spec2, 0, 0);
  2464. xs_list *p2;
  2465. const xs_str *v2;
  2466. p2 = files;
  2467. while (xs_list_iter(&p2, &v2)) {
  2468. tag_gc += index_gc(v2);
  2469. xs *bak = xs_fmt("%s.bak", v2);
  2470. unlink(bak);
  2471. if (index_len(v2) == 0) {
  2472. /* there are no longer any entry with this tag;
  2473. purge it completely */
  2474. unlink(v2);
  2475. xs *dottag = xs_replace(v2, ".idx", ".tag");
  2476. unlink(dottag);
  2477. }
  2478. }
  2479. }
  2480. srv_debug(1, xs_fmt("purge: global "
  2481. "(obj: %d, idx: %d, itl: %d, tag: %d)", cnt, icnt, itl_gc, tag_gc));
  2482. }
  2483. void purge_user(snac *snac)
  2484. /* do the purge for this user */
  2485. {
  2486. int priv_days, pub_days, user_days = 0;
  2487. const char *v;
  2488. int n;
  2489. priv_days = xs_number_get(xs_dict_get(srv_config, "timeline_purge_days"));
  2490. pub_days = xs_number_get(xs_dict_get(srv_config, "local_purge_days"));
  2491. if ((v = xs_dict_get(snac->config_o, "purge_days")) != NULL ||
  2492. (v = xs_dict_get(snac->config, "purge_days")) != NULL)
  2493. user_days = xs_number_get(v);
  2494. if (user_days) {
  2495. /* override admin settings only if they are lesser */
  2496. if (priv_days == 0 || user_days < priv_days)
  2497. priv_days = user_days;
  2498. if (pub_days == 0 || user_days < pub_days)
  2499. pub_days = user_days;
  2500. }
  2501. _purge_user_subdir(snac, "hidden", priv_days);
  2502. _purge_user_subdir(snac, "private", priv_days);
  2503. _purge_user_subdir(snac, "public", pub_days);
  2504. const char *idxs[] = { "followers.idx", "private.idx", "public.idx",
  2505. "pinned.idx", "bookmark.idx", "draft.idx", NULL };
  2506. for (n = 0; idxs[n]; n++) {
  2507. xs *idx = xs_fmt("%s/%s", snac->basedir, idxs[n]);
  2508. int gc = index_gc(idx);
  2509. srv_debug(1, xs_fmt("purge: %s %d", idx, gc));
  2510. }
  2511. /* purge lists */
  2512. {
  2513. xs *spec = xs_fmt("%s/list/" "*.idx", snac->basedir);
  2514. xs *lol = xs_glob(spec, 0, 0);
  2515. int c = 0;
  2516. const char *v;
  2517. while (xs_list_next(lol, &v, &c)) {
  2518. int gc = index_gc(v);
  2519. srv_debug(1, xs_fmt("purge: %s %d", v, gc));
  2520. }
  2521. }
  2522. /* unrelated to purging, but it's a janitorial process, so what the hell */
  2523. verify_links(snac);
  2524. }
  2525. void purge_all(void)
  2526. /* purge all users */
  2527. {
  2528. snac snac;
  2529. xs *list = user_list();
  2530. char *p;
  2531. const char *uid;
  2532. p = list;
  2533. while (xs_list_iter(&p, &uid)) {
  2534. if (user_open(&snac, uid)) {
  2535. purge_user(&snac);
  2536. user_free(&snac);
  2537. }
  2538. }
  2539. purge_server();
  2540. #ifndef NO_MASTODON_API
  2541. mastoapi_purge();
  2542. #endif
  2543. }
  2544. /** archive **/
  2545. void srv_archive(const char *direction, const char *url, xs_dict *req,
  2546. const char *payload, int p_size,
  2547. int status, xs_dict *headers,
  2548. const char *body, int b_size)
  2549. /* archives a connection */
  2550. {
  2551. /* obsessive archiving */
  2552. xs *date = tid(0);
  2553. xs *dir = xs_fmt("%s/archive/%s_%s", srv_basedir, date, direction);
  2554. FILE *f;
  2555. if (mkdirx(dir) != -1) {
  2556. xs *meta_fn = xs_fmt("%s/_META", dir);
  2557. if ((f = fopen(meta_fn, "w")) != NULL) {
  2558. xs *j1 = xs_json_dumps(req, 4);
  2559. xs *j2 = xs_json_dumps(headers, 4);
  2560. fprintf(f, "dir: %s\n", direction);
  2561. if (url)
  2562. fprintf(f, "url: %s\n", url);
  2563. fprintf(f, "req: %s\n", j1);
  2564. fprintf(f, "p_size: %d\n", p_size);
  2565. fprintf(f, "status: %d\n", status);
  2566. fprintf(f, "response: %s\n", j2);
  2567. fprintf(f, "b_size: %d\n", b_size);
  2568. fclose(f);
  2569. }
  2570. if (p_size && payload) {
  2571. xs *payload_fn = NULL;
  2572. xs *payload_fn_raw = NULL;
  2573. const char *v = xs_dict_get(req, "content-type");
  2574. if (v && xs_str_in(v, "json") != -1) {
  2575. payload_fn = xs_fmt("%s/payload.json", dir);
  2576. if ((f = fopen(payload_fn, "w")) != NULL) {
  2577. xs *v1 = xs_json_loads(payload);
  2578. xs *j1 = NULL;
  2579. if (v1 != NULL)
  2580. j1 = xs_json_dumps(v1, 4);
  2581. if (j1 != NULL)
  2582. fwrite(j1, strlen(j1), 1, f);
  2583. else
  2584. fwrite(payload, p_size, 1, f);
  2585. fclose(f);
  2586. }
  2587. }
  2588. payload_fn_raw = xs_fmt("%s/payload", dir);
  2589. if ((f = fopen(payload_fn_raw, "w")) != NULL) {
  2590. fwrite(payload, p_size, 1, f);
  2591. fclose(f);
  2592. }
  2593. }
  2594. if (b_size && body) {
  2595. xs *body_fn = NULL;
  2596. const char *v = xs_dict_get(headers, "content-type");
  2597. if (v && xs_str_in(v, "json") != -1) {
  2598. body_fn = xs_fmt("%s/body.json", dir);
  2599. if ((f = fopen(body_fn, "w")) != NULL) {
  2600. xs *v1 = xs_json_loads(body);
  2601. xs *j1 = NULL;
  2602. if (v1 != NULL)
  2603. j1 = xs_json_dumps(v1, 4);
  2604. if (j1 != NULL)
  2605. fwrite(j1, strlen(j1), 1, f);
  2606. else
  2607. fwrite(body, b_size, 1, f);
  2608. fclose(f);
  2609. }
  2610. }
  2611. else {
  2612. body_fn = xs_fmt("%s/body", dir);
  2613. if ((f = fopen(body_fn, "w")) != NULL) {
  2614. fwrite(body, b_size, 1, f);
  2615. fclose(f);
  2616. }
  2617. }
  2618. }
  2619. }
  2620. }
  2621. void srv_archive_error(const char *prefix, const xs_str *err,
  2622. const xs_dict *req, const xs_val *data)
  2623. /* archives an error */
  2624. {
  2625. xs *ntid = tid(0);
  2626. xs *fn = xs_fmt("%s/error/%s_%s", srv_basedir, ntid, prefix);
  2627. FILE *f;
  2628. if ((f = fopen(fn, "w")) != NULL) {
  2629. fprintf(f, "Error: %s\n", err);
  2630. if (req) {
  2631. fprintf(f, "Request headers:\n");
  2632. xs_json_dump(req, 4, f);
  2633. fprintf(f, "\n");
  2634. }
  2635. if (data) {
  2636. fprintf(f, "Data:\n");
  2637. if (xs_type(data) == XSTYPE_LIST || xs_type(data) == XSTYPE_DICT) {
  2638. xs_json_dump(data, 4, f);
  2639. }
  2640. else
  2641. fprintf(f, "%s", data);
  2642. fprintf(f, "\n");
  2643. }
  2644. fclose(f);
  2645. }
  2646. }
  2647. void srv_archive_qitem(const char *prefix, xs_dict *q_item)
  2648. /* archives a q_item in the error folder */
  2649. {
  2650. xs *ntid = tid(0);
  2651. xs *fn = xs_fmt("%s/error/%s_qitem_%s", srv_basedir, ntid, prefix);
  2652. FILE *f;
  2653. if ((f = fopen(fn, "w")) != NULL) {
  2654. xs_json_dump(q_item, 4, f);
  2655. fclose(f);
  2656. }
  2657. }
  2658. t_announcement *announcement(const double after)
  2659. /* returns announcement text or NULL if none exists or it is olde than "after" */
  2660. {
  2661. static const long int MAX_SIZE = 2048;
  2662. static t_announcement a = {
  2663. .text = NULL,
  2664. .timestamp = 0.0,
  2665. };
  2666. static xs_str *fn = NULL;
  2667. if (fn == NULL)
  2668. fn = xs_fmt("%s/announcement.txt", srv_basedir);
  2669. const double ts = mtime(fn);
  2670. /* file does not exist or other than what was requested */
  2671. if (ts == 0.0 || ts <= after)
  2672. return NULL;
  2673. /* nothing changed, just return the current announcement */
  2674. if (a.text != NULL && ts <= a.timestamp)
  2675. return &a;
  2676. /* read and store new announcement */
  2677. FILE *f;
  2678. if ((f = fopen(fn, "r")) != NULL) {
  2679. fseek (f, 0, SEEK_END);
  2680. const long int length = ftell(f);
  2681. if (length > MAX_SIZE) {
  2682. /* this is probably unintentional */
  2683. srv_log(xs_fmt("announcement.txt too big: %ld bytes, max is %ld, ignoring.", length, MAX_SIZE));
  2684. }
  2685. else
  2686. if (length > 0) {
  2687. fseek (f, 0, SEEK_SET);
  2688. char *buffer = malloc(length + 1);
  2689. if (buffer) {
  2690. fread(buffer, 1, length, f);
  2691. buffer[length] = '\0';
  2692. free(a.text);
  2693. a.text = buffer;
  2694. a.timestamp = ts;
  2695. }
  2696. else {
  2697. srv_log("Error allocating memory for announcement");
  2698. }
  2699. }
  2700. else {
  2701. /* an empty file means no announcement */
  2702. free(a.text);
  2703. a.text = NULL;
  2704. a.timestamp = 0.0;
  2705. }
  2706. fclose (f);
  2707. }
  2708. if (a.text != NULL)
  2709. return &a;
  2710. return NULL;
  2711. }
  2712. xs_str *make_url(const char *href, const char *proxy, int by_token)
  2713. /* makes an URL, possibly including proxying */
  2714. {
  2715. xs_str *url = NULL;
  2716. if (proxy && !xs_startswith(href, srv_baseurl)) {
  2717. xs *p = NULL;
  2718. if (by_token) {
  2719. xs *tks = xs_fmt("%s:%s", srv_proxy_token_seed, proxy);
  2720. xs *tk = xs_md5_hex(tks, strlen(tks));
  2721. p = xs_fmt("%s/y/%s/", proxy, tk);
  2722. }
  2723. else
  2724. p = xs_fmt("%s/x/", proxy);
  2725. url = xs_replace(href, "https:/" "/", p);
  2726. }
  2727. else
  2728. url = xs_dup(href);
  2729. return url;
  2730. }