data.c 88 KB

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