added ignoring remaining level chunks after chunks with wrong size
[rocksndiamonds.git] / src / api.c
1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2022 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // api.c
10 // ============================================================================
11
12 #include "libgame/libgame.h"
13
14 #include "api.h"
15 #include "main.h"
16 #include "files.h"
17 #include "config.h"
18
19
20 // ============================================================================
21 // generic helper functions
22 // ============================================================================
23
24 static void ExecuteAsThread(SDL_ThreadFunction function, char *name, void *data,
25                             char *error)
26 {
27 #if defined(PLATFORM_EMSCRIPTEN)
28   // threads currently not fully supported by Emscripten/SDL and some browsers
29   function(data);
30 #else
31   SDL_Thread *thread = SDL_CreateThread(function, name, data);
32
33   if (thread != NULL)
34     SDL_DetachThread(thread);
35   else
36     Error("Cannot create thread to %s!", error);
37
38   // nasty kludge to lower probability of intermingled thread error messages
39   Delay(1);
40 #endif
41 }
42
43 static char *getPasswordJSON(char *password)
44 {
45   static char password_json[MAX_FILENAME_LEN] = "";
46   static boolean initialized = FALSE;
47
48   if (!initialized)
49   {
50     if (password != NULL &&
51         !strEqual(password, "") &&
52         !strEqual(password, UNDEFINED_PASSWORD))
53       snprintf(password_json, MAX_FILENAME_LEN,
54                "  \"password\":             \"%s\",\n",
55                setup.api_server_password);
56
57     initialized = TRUE;
58   }
59
60   return password_json;
61 }
62
63 static char *getFileBase64(char *filename)
64 {
65   struct stat file_status;
66
67   if (stat(filename, &file_status) != 0)
68   {
69     Error("cannot stat file '%s'", filename);
70
71     return NULL;
72   }
73
74   int buffer_size = file_status.st_size;
75   byte *buffer = checked_malloc(buffer_size);
76   FILE *file;
77   int i;
78
79   if (!(file = fopen(filename, MODE_READ)))
80   {
81     Error("cannot open file '%s'", filename);
82
83     checked_free(buffer);
84
85     return NULL;
86   }
87
88   for (i = 0; i < buffer_size; i++)
89   {
90     int c = fgetc(file);
91
92     if (c == EOF)
93     {
94       Error("cannot read from input file '%s'", filename);
95
96       fclose(file);
97       checked_free(buffer);
98
99       return NULL;
100     }
101
102     buffer[i] = (byte)c;
103   }
104
105   fclose(file);
106
107   int buffer_encoded_size = base64_encoded_size(buffer_size);
108   char *buffer_encoded = checked_malloc(buffer_encoded_size);
109
110   base64_encode(buffer_encoded, buffer, buffer_size);
111
112   checked_free(buffer);
113
114   return buffer_encoded;
115 }
116
117
118 // ============================================================================
119 // add score API functions
120 // ============================================================================
121
122 struct ApiAddScoreThreadData
123 {
124   int level_nr;
125   boolean tape_saved;
126   char *leveldir_subdir;
127   char *score_tape_filename;
128   struct ScoreEntry score_entry;
129 };
130
131 static void *CreateThreadData_ApiAddScore(int nr, boolean tape_saved,
132                                           char *score_tape_filename)
133 {
134   struct ApiAddScoreThreadData *data =
135     checked_malloc(sizeof(struct ApiAddScoreThreadData));
136   struct ScoreEntry *score_entry = &scores.entry[scores.last_added];
137
138   if (score_tape_filename == NULL)
139     score_tape_filename = getScoreTapeFilename(score_entry->tape_basename, nr);
140
141   data->level_nr = nr;
142   data->tape_saved = tape_saved;
143   data->leveldir_subdir = getStringCopy(leveldir_current->subdir);
144   data->score_tape_filename = getStringCopy(score_tape_filename);
145   data->score_entry = *score_entry;
146
147   return data;
148 }
149
150 static void FreeThreadData_ApiAddScore(void *data_raw)
151 {
152   struct ApiAddScoreThreadData *data = data_raw;
153
154   checked_free(data->leveldir_subdir);
155   checked_free(data->score_tape_filename);
156   checked_free(data);
157 }
158
159 static boolean SetRequest_ApiAddScore(struct HttpRequest *request,
160                                       void *data_raw)
161 {
162   struct ApiAddScoreThreadData *data = data_raw;
163   struct ScoreEntry *score_entry = &data->score_entry;
164   char *score_tape_filename = data->score_tape_filename;
165   boolean tape_saved = data->tape_saved;
166   int level_nr = data->level_nr;
167
168   request->hostname = setup.api_server_hostname;
169   request->port     = API_SERVER_PORT;
170   request->method   = API_SERVER_METHOD;
171   request->uri      = API_SERVER_URI_ADD;
172
173   char *tape_base64 = getFileBase64(score_tape_filename);
174
175   if (tape_base64 == NULL)
176   {
177     Error("loading and base64 encoding score tape file failed");
178
179     return FALSE;
180   }
181
182   char *player_name_raw = score_entry->name;
183   char *player_uuid_raw = setup.player_uuid;
184
185   if (options.player_name != NULL && global.autoplay_leveldir != NULL)
186   {
187     player_name_raw = options.player_name;
188     player_uuid_raw = "";
189   }
190
191   char *levelset_identifier = getEscapedJSON(leveldir_current->identifier);
192   char *levelset_name       = getEscapedJSON(leveldir_current->name);
193   char *levelset_author     = getEscapedJSON(leveldir_current->author);
194   char *level_name          = getEscapedJSON(level.name);
195   char *level_author        = getEscapedJSON(level.author);
196   char *player_name         = getEscapedJSON(player_name_raw);
197   char *player_uuid         = getEscapedJSON(player_uuid_raw);
198
199   snprintf(request->body, MAX_HTTP_BODY_SIZE,
200            "{\n"
201            "%s"
202            "  \"game_version\":         \"%s\",\n"
203            "  \"game_platform\":        \"%s\",\n"
204            "  \"batch_time\":           \"%d\",\n"
205            "  \"levelset_identifier\":  \"%s\",\n"
206            "  \"levelset_name\":        \"%s\",\n"
207            "  \"levelset_author\":      \"%s\",\n"
208            "  \"levelset_num_levels\":  \"%d\",\n"
209            "  \"levelset_first_level\": \"%d\",\n"
210            "  \"level_nr\":             \"%d\",\n"
211            "  \"level_name\":           \"%s\",\n"
212            "  \"level_author\":         \"%s\",\n"
213            "  \"use_step_counter\":     \"%d\",\n"
214            "  \"rate_time_over_score\": \"%d\",\n"
215            "  \"player_name\":          \"%s\",\n"
216            "  \"player_uuid\":          \"%s\",\n"
217            "  \"score\":                \"%d\",\n"
218            "  \"time\":                 \"%d\",\n"
219            "  \"tape_basename\":        \"%s\",\n"
220            "  \"tape_saved\":           \"%d\",\n"
221            "  \"tape\":                 \"%s\"\n"
222            "}\n",
223            getPasswordJSON(setup.api_server_password),
224            getProgramRealVersionString(),
225            getProgramPlatformString(),
226            (int)global.autoplay_time,
227            levelset_identifier,
228            levelset_name,
229            levelset_author,
230            leveldir_current->levels,
231            leveldir_current->first_level,
232            level_nr,
233            level_name,
234            level_author,
235            level.use_step_counter,
236            level.rate_time_over_score,
237            player_name,
238            player_uuid,
239            score_entry->score,
240            score_entry->time,
241            score_entry->tape_basename,
242            tape_saved,
243            tape_base64);
244
245   checked_free(tape_base64);
246
247   checked_free(levelset_identifier);
248   checked_free(levelset_name);
249   checked_free(levelset_author);
250   checked_free(level_name);
251   checked_free(level_author);
252   checked_free(player_name);
253   checked_free(player_uuid);
254
255   ConvertHttpRequestBodyToServerEncoding(request);
256
257   return TRUE;
258 }
259
260 static void HandleResponse_ApiAddScore(struct HttpResponse *response,
261                                        void *data_raw)
262 {
263   server_scores.uploaded = TRUE;
264 }
265
266 static void HandleFailure_ApiAddScore(void *data_raw)
267 {
268   struct ApiAddScoreThreadData *data = data_raw;
269
270   PrepareScoreTapesForUpload(data->leveldir_subdir);
271 }
272
273 #if defined(PLATFORM_EMSCRIPTEN)
274 static void Emscripten_ApiAddScore_Loaded(unsigned handle, void *data_raw,
275                                           void *buffer, unsigned int size)
276 {
277   struct HttpResponse *response = GetHttpResponseFromBuffer(buffer, size);
278
279   if (response != NULL)
280   {
281     HandleResponse_ApiAddScore(response, data_raw);
282
283     checked_free(response);
284   }
285   else
286   {
287     Error("server response too large to handle (%d bytes)", size);
288
289     HandleFailure_ApiAddScore(data_raw);
290   }
291
292   FreeThreadData_ApiAddScore(data_raw);
293 }
294
295 static void Emscripten_ApiAddScore_Failed(unsigned handle, void *data_raw,
296                                           int code, const char *status)
297 {
298   Error("server failed to handle request: %d %s", code, status);
299
300   HandleFailure_ApiAddScore(data_raw);
301
302   FreeThreadData_ApiAddScore(data_raw);
303 }
304
305 static void Emscripten_ApiAddScore_Progress(unsigned handle, void *data_raw,
306                                             int bytes, int size)
307 {
308   // nothing to do here
309 }
310
311 static void Emscripten_ApiAddScore_HttpRequest(struct HttpRequest *request,
312                                                void *data_raw)
313 {
314   if (!SetRequest_ApiAddScore(request, data_raw))
315   {
316     FreeThreadData_ApiAddScore(data_raw);
317
318     return;
319   }
320
321   emscripten_async_wget2_data(request->uri,
322                               request->method,
323                               request->body,
324                               data_raw,
325                               TRUE,
326                               Emscripten_ApiAddScore_Loaded,
327                               Emscripten_ApiAddScore_Failed,
328                               Emscripten_ApiAddScore_Progress);
329 }
330
331 #else
332
333 static void ApiAddScore_HttpRequestExt(struct HttpRequest *request,
334                                        struct HttpResponse *response,
335                                        void *data_raw)
336 {
337   if (!SetRequest_ApiAddScore(request, data_raw))
338     return;
339
340   if (!DoHttpRequest(request, response))
341   {
342     Error("HTTP request failed: %s", GetHttpError());
343
344     HandleFailure_ApiAddScore(data_raw);
345
346     return;
347   }
348
349   if (!HTTP_SUCCESS(response->status_code))
350   {
351     Error("server failed to handle request: %d %s",
352           response->status_code,
353           response->status_text);
354
355     HandleFailure_ApiAddScore(data_raw);
356
357     return;
358   }
359
360   HandleResponse_ApiAddScore(response, data_raw);
361 }
362
363 static void ApiAddScore_HttpRequest(struct HttpRequest *request,
364                                     struct HttpResponse *response,
365                                     void *data_raw)
366 {
367   ApiAddScore_HttpRequestExt(request, response, data_raw);
368
369   FreeThreadData_ApiAddScore(data_raw);
370 }
371 #endif
372
373 static int ApiAddScoreThread(void *data_raw)
374 {
375   struct HttpRequest *request = checked_calloc(sizeof(struct HttpRequest));
376   struct HttpResponse *response = checked_calloc(sizeof(struct HttpResponse));
377
378   program.api_thread_count++;
379
380 #if defined(PLATFORM_EMSCRIPTEN)
381   Emscripten_ApiAddScore_HttpRequest(request, data_raw);
382 #else
383   ApiAddScore_HttpRequest(request, response, data_raw);
384 #endif
385
386   program.api_thread_count--;
387
388   checked_free(request);
389   checked_free(response);
390
391   return 0;
392 }
393
394 void ApiAddScoreAsThread(int nr, boolean tape_saved, char *score_tape_filename)
395 {
396   struct ApiAddScoreThreadData *data =
397     CreateThreadData_ApiAddScore(nr, tape_saved, score_tape_filename);
398
399   ExecuteAsThread(ApiAddScoreThread,
400                   "ApiAddScore", data,
401                   "upload score to server");
402 }
403
404
405 // ============================================================================
406 // get score API functions
407 // ============================================================================
408
409 struct ApiGetScoreThreadData
410 {
411   int level_nr;
412   char *score_cache_filename;
413 };
414
415 static void *CreateThreadData_ApiGetScore(int nr)
416 {
417   struct ApiGetScoreThreadData *data =
418     checked_malloc(sizeof(struct ApiGetScoreThreadData));
419   char *score_cache_filename = getScoreCacheFilename(nr);
420
421   data->level_nr = nr;
422   data->score_cache_filename = getStringCopy(score_cache_filename);
423
424   return data;
425 }
426
427 static void FreeThreadData_ApiGetScore(void *data_raw)
428 {
429   struct ApiGetScoreThreadData *data = data_raw;
430
431   checked_free(data->score_cache_filename);
432   checked_free(data);
433 }
434
435 static boolean SetRequest_ApiGetScore(struct HttpRequest *request,
436                                       void *data_raw)
437 {
438   struct ApiGetScoreThreadData *data = data_raw;
439   int level_nr = data->level_nr;
440
441   request->hostname = setup.api_server_hostname;
442   request->port     = API_SERVER_PORT;
443   request->method   = API_SERVER_METHOD;
444   request->uri      = API_SERVER_URI_GET;
445
446   char *levelset_identifier = getEscapedJSON(leveldir_current->identifier);
447   char *levelset_name       = getEscapedJSON(leveldir_current->name);
448
449   snprintf(request->body, MAX_HTTP_BODY_SIZE,
450            "{\n"
451            "%s"
452            "  \"game_version\":         \"%s\",\n"
453            "  \"game_platform\":        \"%s\",\n"
454            "  \"levelset_identifier\":  \"%s\",\n"
455            "  \"levelset_name\":        \"%s\",\n"
456            "  \"level_nr\":             \"%d\"\n"
457            "}\n",
458            getPasswordJSON(setup.api_server_password),
459            getProgramRealVersionString(),
460            getProgramPlatformString(),
461            levelset_identifier,
462            levelset_name,
463            level_nr);
464
465   checked_free(levelset_identifier);
466   checked_free(levelset_name);
467
468   ConvertHttpRequestBodyToServerEncoding(request);
469
470   return TRUE;
471 }
472
473 static void HandleResponse_ApiGetScore(struct HttpResponse *response,
474                                        void *data_raw)
475 {
476   struct ApiGetScoreThreadData *data = data_raw;
477
478   if (response->body_size == 0)
479   {
480     // no scores available for this level
481
482     return;
483   }
484
485   ConvertHttpResponseBodyToClientEncoding(response);
486
487   char *filename = data->score_cache_filename;
488   FILE *file;
489   int i;
490
491   // used instead of "leveldir_current->subdir" (for network games)
492   InitScoreCacheDirectory(levelset.identifier);
493
494   if (!(file = fopen(filename, MODE_WRITE)))
495   {
496     Warn("cannot save score cache file '%s'", filename);
497
498     return;
499   }
500
501   for (i = 0; i < response->body_size; i++)
502     fputc(response->body[i], file);
503
504   fclose(file);
505
506   SetFilePermissions(filename, PERMS_PRIVATE);
507
508   server_scores.updated = TRUE;
509 }
510
511 #if defined(PLATFORM_EMSCRIPTEN)
512 static void Emscripten_ApiGetScore_Loaded(unsigned handle, void *data_raw,
513                                           void *buffer, unsigned int size)
514 {
515   struct HttpResponse *response = GetHttpResponseFromBuffer(buffer, size);
516
517   if (response != NULL)
518   {
519     HandleResponse_ApiGetScore(response, data_raw);
520
521     checked_free(response);
522   }
523   else
524   {
525     Error("server response too large to handle (%d bytes)", size);
526   }
527
528   FreeThreadData_ApiGetScore(data_raw);
529 }
530
531 static void Emscripten_ApiGetScore_Failed(unsigned handle, void *data_raw,
532                                           int code, const char *status)
533 {
534   Error("server failed to handle request: %d %s", code, status);
535
536   FreeThreadData_ApiGetScore(data_raw);
537 }
538
539 static void Emscripten_ApiGetScore_Progress(unsigned handle, void *data_raw,
540                                             int bytes, int size)
541 {
542   // nothing to do here
543 }
544
545 static void Emscripten_ApiGetScore_HttpRequest(struct HttpRequest *request,
546                                                void *data_raw)
547 {
548   if (!SetRequest_ApiGetScore(request, data_raw))
549   {
550     FreeThreadData_ApiGetScore(data_raw);
551
552     return;
553   }
554
555   emscripten_async_wget2_data(request->uri,
556                               request->method,
557                               request->body,
558                               data_raw,
559                               TRUE,
560                               Emscripten_ApiGetScore_Loaded,
561                               Emscripten_ApiGetScore_Failed,
562                               Emscripten_ApiGetScore_Progress);
563 }
564
565 #else
566
567 static void ApiGetScore_HttpRequestExt(struct HttpRequest *request,
568                                        struct HttpResponse *response,
569                                        void *data_raw)
570 {
571   if (!SetRequest_ApiGetScore(request, data_raw))
572     return;
573
574   if (!DoHttpRequest(request, response))
575   {
576     Error("HTTP request failed: %s", GetHttpError());
577
578     return;
579   }
580
581   if (!HTTP_SUCCESS(response->status_code))
582   {
583     // do not show error message if no scores found for this level set
584     if (response->status_code == 404)
585       return;
586
587     Error("server failed to handle request: %d %s",
588           response->status_code,
589           response->status_text);
590
591     return;
592   }
593
594   HandleResponse_ApiGetScore(response, data_raw);
595 }
596
597 static void ApiGetScore_HttpRequest(struct HttpRequest *request,
598                                     struct HttpResponse *response,
599                                     void *data_raw)
600 {
601   ApiGetScore_HttpRequestExt(request, response, data_raw);
602
603   FreeThreadData_ApiGetScore(data_raw);
604 }
605 #endif
606
607 static int ApiGetScoreThread(void *data_raw)
608 {
609   struct HttpRequest *request = checked_calloc(sizeof(struct HttpRequest));
610   struct HttpResponse *response = checked_calloc(sizeof(struct HttpResponse));
611
612   program.api_thread_count++;
613
614 #if defined(PLATFORM_EMSCRIPTEN)
615   Emscripten_ApiGetScore_HttpRequest(request, data_raw);
616 #else
617   ApiGetScore_HttpRequest(request, response, data_raw);
618 #endif
619
620   program.api_thread_count--;
621
622   checked_free(request);
623   checked_free(response);
624
625   return 0;
626 }
627
628 void ApiGetScoreAsThread(int nr)
629 {
630   struct ApiGetScoreThreadData *data = CreateThreadData_ApiGetScore(nr);
631
632   ExecuteAsThread(ApiGetScoreThread,
633                   "ApiGetScore", data,
634                   "download scores from server");
635 }
636
637
638 // ============================================================================
639 // get score tape API functions
640 // ============================================================================
641
642 struct ApiGetScoreTapeThreadData
643 {
644   int level_nr;
645   int score_id;
646   char *score_tape_filename;
647 };
648
649 static void *CreateThreadData_ApiGetScoreTape(int nr, int id,
650                                               char *score_tape_basename)
651 {
652   struct ApiGetScoreTapeThreadData *data =
653     checked_malloc(sizeof(struct ApiGetScoreTapeThreadData));
654   char *score_tape_filename = getScoreCacheTapeFilename(score_tape_basename, nr);
655
656   data->level_nr = nr;
657   data->score_id = id;
658   data->score_tape_filename = getStringCopy(score_tape_filename);
659
660   return data;
661 }
662
663 static void FreeThreadData_ApiGetScoreTape(void *data_raw)
664 {
665   struct ApiGetScoreTapeThreadData *data = data_raw;
666
667   checked_free(data->score_tape_filename);
668   checked_free(data);
669 }
670
671 static boolean SetRequest_ApiGetScoreTape(struct HttpRequest *request,
672                                           void *data_raw)
673 {
674   struct ApiGetScoreTapeThreadData *data = data_raw;
675   int score_id = data->score_id;
676
677   request->hostname = setup.api_server_hostname;
678   request->port     = API_SERVER_PORT;
679   request->method   = API_SERVER_METHOD;
680   request->uri      = API_SERVER_URI_GETTAPE;
681
682   snprintf(request->body, MAX_HTTP_BODY_SIZE,
683            "{\n"
684            "%s"
685            "  \"game_version\":         \"%s\",\n"
686            "  \"game_platform\":        \"%s\",\n"
687            "  \"id\":                   \"%d\"\n"
688            "}\n",
689            getPasswordJSON(setup.api_server_password),
690            getProgramRealVersionString(),
691            getProgramPlatformString(),
692            score_id);
693
694   ConvertHttpRequestBodyToServerEncoding(request);
695
696   return TRUE;
697 }
698
699 static void HandleResponse_ApiGetScoreTape(struct HttpResponse *response,
700                                            void *data_raw)
701 {
702   struct ApiGetScoreTapeThreadData *data = data_raw;
703
704   if (response->body_size == 0)
705   {
706     // no score tape available for this level
707
708     return;
709   }
710
711   // (do not convert HTTP response body, as it contains binary data here)
712
713   int level_nr = data->level_nr;
714   char *filename = data->score_tape_filename;
715   FILE *file;
716   int i;
717
718   // used instead of "leveldir_current->subdir" (for network games)
719   InitScoreCacheTapeDirectory(levelset.identifier, level_nr);
720
721   if (!(file = fopen(filename, MODE_WRITE)))
722   {
723     Warn("cannot save score tape file '%s'", filename);
724
725     return;
726   }
727
728   for (i = 0; i < response->body_size; i++)
729     fputc(response->body[i], file);
730
731   fclose(file);
732
733   SetFilePermissions(filename, PERMS_PRIVATE);
734
735   server_scores.tape_downloaded = TRUE;
736 }
737
738 #if defined(PLATFORM_EMSCRIPTEN)
739 static void Emscripten_ApiGetScoreTape_Loaded(unsigned handle, void *data_raw,
740                                               void *buffer, unsigned int size)
741 {
742   struct HttpResponse *response = GetHttpResponseFromBuffer(buffer, size);
743
744   if (response != NULL)
745   {
746     HandleResponse_ApiGetScoreTape(response, data_raw);
747
748     checked_free(response);
749   }
750   else
751   {
752     Error("server response too large to handle (%d bytes)", size);
753   }
754
755   FreeThreadData_ApiGetScoreTape(data_raw);
756 }
757
758 static void Emscripten_ApiGetScoreTape_Failed(unsigned handle, void *data_raw,
759                                               int code, const char *status)
760 {
761   Error("server failed to handle request: %d %s", code, status);
762
763   FreeThreadData_ApiGetScoreTape(data_raw);
764 }
765
766 static void Emscripten_ApiGetScoreTape_Progress(unsigned handle, void *data_raw,
767                                                 int bytes, int size)
768 {
769   // nothing to do here
770 }
771
772 static void Emscripten_ApiGetScoreTape_HttpRequest(struct HttpRequest *request,
773                                                    void *data_raw)
774 {
775   if (!SetRequest_ApiGetScoreTape(request, data_raw))
776   {
777     FreeThreadData_ApiGetScoreTape(data_raw);
778
779     return;
780   }
781
782   emscripten_async_wget2_data(request->uri,
783                               request->method,
784                               request->body,
785                               data_raw,
786                               TRUE,
787                               Emscripten_ApiGetScoreTape_Loaded,
788                               Emscripten_ApiGetScoreTape_Failed,
789                               Emscripten_ApiGetScoreTape_Progress);
790 }
791
792 #else
793
794 static void ApiGetScoreTape_HttpRequestExt(struct HttpRequest *request,
795                                            struct HttpResponse *response,
796                                            void *data_raw)
797 {
798   if (!SetRequest_ApiGetScoreTape(request, data_raw))
799     return;
800
801   if (!DoHttpRequest(request, response))
802   {
803     Error("HTTP request failed: %s", GetHttpError());
804
805     return;
806   }
807
808   if (!HTTP_SUCCESS(response->status_code))
809   {
810     // do not show error message if no scores found for this level set
811     if (response->status_code == 404)
812       return;
813
814     Error("server failed to handle request: %d %s",
815           response->status_code,
816           response->status_text);
817
818     return;
819   }
820
821   HandleResponse_ApiGetScoreTape(response, data_raw);
822 }
823
824 static void ApiGetScoreTape_HttpRequest(struct HttpRequest *request,
825                                         struct HttpResponse *response,
826                                         void *data_raw)
827 {
828   ApiGetScoreTape_HttpRequestExt(request, response, data_raw);
829
830   FreeThreadData_ApiGetScoreTape(data_raw);
831 }
832 #endif
833
834 static int ApiGetScoreTapeThread(void *data_raw)
835 {
836   struct HttpRequest *request = checked_calloc(sizeof(struct HttpRequest));
837   struct HttpResponse *response = checked_calloc(sizeof(struct HttpResponse));
838
839   program.api_thread_count++;
840
841 #if defined(PLATFORM_EMSCRIPTEN)
842   Emscripten_ApiGetScoreTape_HttpRequest(request, data_raw);
843 #else
844   ApiGetScoreTape_HttpRequest(request, response, data_raw);
845 #endif
846
847   program.api_thread_count--;
848
849   checked_free(request);
850   checked_free(response);
851
852   return 0;
853 }
854
855 void ApiGetScoreTapeAsThread(int nr, int id, char *score_tape_basename)
856 {
857   struct ApiGetScoreTapeThreadData *data =
858     CreateThreadData_ApiGetScoreTape(nr, id, score_tape_basename);
859
860   ExecuteAsThread(ApiGetScoreTapeThread,
861                   "ApiGetScoreTape", data,
862                   "download score tape from server");
863 }
864
865
866 // ============================================================================
867 // rename player API functions
868 // ============================================================================
869
870 struct ApiRenamePlayerThreadData
871 {
872   char *player_name;
873   char *player_uuid;
874 };
875
876 static void *CreateThreadData_ApiRenamePlayer(void)
877 {
878   struct ApiRenamePlayerThreadData *data =
879     checked_malloc(sizeof(struct ApiRenamePlayerThreadData));
880
881   data->player_name = getStringCopy(setup.player_name);
882   data->player_uuid = getStringCopy(setup.player_uuid);
883
884   return data;
885 }
886
887 static void FreeThreadData_ApiRenamePlayer(void *data_raw)
888 {
889   struct ApiRenamePlayerThreadData *data = data_raw;
890
891   checked_free(data->player_name);
892   checked_free(data->player_uuid);
893   checked_free(data);
894 }
895
896 static boolean SetRequest_ApiRenamePlayer(struct HttpRequest *request,
897                                           void *data_raw)
898 {
899   struct ApiRenamePlayerThreadData *data = data_raw;
900   char *player_name_raw = data->player_name;
901   char *player_uuid_raw = data->player_uuid;
902
903   request->hostname = setup.api_server_hostname;
904   request->port     = API_SERVER_PORT;
905   request->method   = API_SERVER_METHOD;
906   request->uri      = API_SERVER_URI_RENAME;
907
908   char *player_name = getEscapedJSON(player_name_raw);
909   char *player_uuid = getEscapedJSON(player_uuid_raw);
910
911   snprintf(request->body, MAX_HTTP_BODY_SIZE,
912            "{\n"
913            "%s"
914            "  \"game_version\":         \"%s\",\n"
915            "  \"game_platform\":        \"%s\",\n"
916            "  \"name\":                 \"%s\",\n"
917            "  \"uuid\":                 \"%s\"\n"
918            "}\n",
919            getPasswordJSON(setup.api_server_password),
920            getProgramRealVersionString(),
921            getProgramPlatformString(),
922            player_name,
923            player_uuid);
924
925   checked_free(player_name);
926   checked_free(player_uuid);
927
928   ConvertHttpRequestBodyToServerEncoding(request);
929
930   return TRUE;
931 }
932
933 static void HandleResponse_ApiRenamePlayer(struct HttpResponse *response,
934                                            void *data_raw)
935 {
936   // nothing to do here
937 }
938
939 #if defined(PLATFORM_EMSCRIPTEN)
940 static void Emscripten_ApiRenamePlayer_Loaded(unsigned handle, void *data_raw,
941                                               void *buffer, unsigned int size)
942 {
943   struct HttpResponse *response = GetHttpResponseFromBuffer(buffer, size);
944
945   if (response != NULL)
946   {
947     HandleResponse_ApiRenamePlayer(response, data_raw);
948
949     checked_free(response);
950   }
951   else
952   {
953     Error("server response too large to handle (%d bytes)", size);
954   }
955
956   FreeThreadData_ApiRenamePlayer(data_raw);
957 }
958
959 static void Emscripten_ApiRenamePlayer_Failed(unsigned handle, void *data_raw,
960                                               int code, const char *status)
961 {
962   Error("server failed to handle request: %d %s", code, status);
963
964   FreeThreadData_ApiRenamePlayer(data_raw);
965 }
966
967 static void Emscripten_ApiRenamePlayer_Progress(unsigned handle, void *data_raw,
968                                                 int bytes, int size)
969 {
970   // nothing to do here
971 }
972
973 static void Emscripten_ApiRenamePlayer_HttpRequest(struct HttpRequest *request,
974                                                    void *data_raw)
975 {
976   if (!SetRequest_ApiRenamePlayer(request, data_raw))
977   {
978     FreeThreadData_ApiRenamePlayer(data_raw);
979
980     return;
981   }
982
983   emscripten_async_wget2_data(request->uri,
984                               request->method,
985                               request->body,
986                               data_raw,
987                               TRUE,
988                               Emscripten_ApiRenamePlayer_Loaded,
989                               Emscripten_ApiRenamePlayer_Failed,
990                               Emscripten_ApiRenamePlayer_Progress);
991 }
992
993 #else
994
995 static void ApiRenamePlayer_HttpRequestExt(struct HttpRequest *request,
996                                            struct HttpResponse *response,
997                                            void *data_raw)
998 {
999   if (!SetRequest_ApiRenamePlayer(request, data_raw))
1000     return;
1001
1002   if (!DoHttpRequest(request, response))
1003   {
1004     Error("HTTP request failed: %s", GetHttpError());
1005
1006     return;
1007   }
1008
1009   if (!HTTP_SUCCESS(response->status_code))
1010   {
1011     Error("server failed to handle request: %d %s",
1012           response->status_code,
1013           response->status_text);
1014
1015     return;
1016   }
1017
1018   HandleResponse_ApiRenamePlayer(response, data_raw);
1019 }
1020
1021 static void ApiRenamePlayer_HttpRequest(struct HttpRequest *request,
1022                                     struct HttpResponse *response,
1023                                     void *data_raw)
1024 {
1025   ApiRenamePlayer_HttpRequestExt(request, response, data_raw);
1026
1027   FreeThreadData_ApiRenamePlayer(data_raw);
1028 }
1029 #endif
1030
1031 static int ApiRenamePlayerThread(void *data_raw)
1032 {
1033   struct HttpRequest *request = checked_calloc(sizeof(struct HttpRequest));
1034   struct HttpResponse *response = checked_calloc(sizeof(struct HttpResponse));
1035
1036   program.api_thread_count++;
1037
1038 #if defined(PLATFORM_EMSCRIPTEN)
1039   Emscripten_ApiRenamePlayer_HttpRequest(request, data_raw);
1040 #else
1041   ApiRenamePlayer_HttpRequest(request, response, data_raw);
1042 #endif
1043
1044   program.api_thread_count--;
1045
1046   checked_free(request);
1047   checked_free(response);
1048
1049   return 0;
1050 }
1051
1052 void ApiRenamePlayerAsThread(void)
1053 {
1054   struct ApiRenamePlayerThreadData *data = CreateThreadData_ApiRenamePlayer();
1055
1056   ExecuteAsThread(ApiRenamePlayerThread,
1057                   "ApiRenamePlayer", data,
1058                   "rename player on server");
1059 }
1060
1061
1062 // ============================================================================
1063 // reset player UUID API functions
1064 // ============================================================================
1065
1066 struct ApiResetUUIDThreadData
1067 {
1068   char *player_name;
1069   char *player_uuid_old;
1070   char *player_uuid_new;
1071 };
1072
1073 static void *CreateThreadData_ApiResetUUID(char *uuid_new)
1074 {
1075   struct ApiResetUUIDThreadData *data =
1076     checked_malloc(sizeof(struct ApiResetUUIDThreadData));
1077
1078   data->player_name     = getStringCopy(setup.player_name);
1079   data->player_uuid_old = getStringCopy(setup.player_uuid);
1080   data->player_uuid_new = getStringCopy(uuid_new);
1081
1082   return data;
1083 }
1084
1085 static void FreeThreadData_ApiResetUUID(void *data_raw)
1086 {
1087   struct ApiResetUUIDThreadData *data = data_raw;
1088
1089   checked_free(data->player_name);
1090   checked_free(data->player_uuid_old);
1091   checked_free(data->player_uuid_new);
1092   checked_free(data);
1093 }
1094
1095 static boolean SetRequest_ApiResetUUID(struct HttpRequest *request,
1096                                        void *data_raw)
1097 {
1098   struct ApiResetUUIDThreadData *data = data_raw;
1099   char *player_name_raw = data->player_name;
1100   char *player_uuid_old_raw = data->player_uuid_old;
1101   char *player_uuid_new_raw = data->player_uuid_new;
1102
1103   request->hostname = setup.api_server_hostname;
1104   request->port     = API_SERVER_PORT;
1105   request->method   = API_SERVER_METHOD;
1106   request->uri      = API_SERVER_URI_RESETUUID;
1107
1108   char *player_name = getEscapedJSON(player_name_raw);
1109   char *player_uuid_old = getEscapedJSON(player_uuid_old_raw);
1110   char *player_uuid_new = getEscapedJSON(player_uuid_new_raw);
1111
1112   snprintf(request->body, MAX_HTTP_BODY_SIZE,
1113            "{\n"
1114            "%s"
1115            "  \"game_version\":         \"%s\",\n"
1116            "  \"game_platform\":        \"%s\",\n"
1117            "  \"name\":                 \"%s\",\n"
1118            "  \"uuid_old\":             \"%s\",\n"
1119            "  \"uuid_new\":             \"%s\"\n"
1120            "}\n",
1121            getPasswordJSON(setup.api_server_password),
1122            getProgramRealVersionString(),
1123            getProgramPlatformString(),
1124            player_name,
1125            player_uuid_old,
1126            player_uuid_new);
1127
1128   checked_free(player_name);
1129   checked_free(player_uuid_old);
1130   checked_free(player_uuid_new);
1131
1132   ConvertHttpRequestBodyToServerEncoding(request);
1133
1134   return TRUE;
1135 }
1136
1137 static void HandleResponse_ApiResetUUID(struct HttpResponse *response,
1138                                         void *data_raw)
1139 {
1140   struct ApiResetUUIDThreadData *data = data_raw;
1141
1142   // upgrade player UUID in server setup file
1143   setup.player_uuid = getStringCopy(data->player_uuid_new);
1144   setup.player_version = 2;
1145
1146   SaveSetup_ServerSetup();
1147 }
1148
1149 #if defined(PLATFORM_EMSCRIPTEN)
1150 static void Emscripten_ApiResetUUID_Loaded(unsigned handle, void *data_raw,
1151                                            void *buffer, unsigned int size)
1152 {
1153   struct HttpResponse *response = GetHttpResponseFromBuffer(buffer, size);
1154
1155   if (response != NULL)
1156   {
1157     HandleResponse_ApiResetUUID(response, data_raw);
1158
1159     checked_free(response);
1160   }
1161   else
1162   {
1163     Error("server response too large to handle (%d bytes)", size);
1164   }
1165
1166   FreeThreadData_ApiResetUUID(data_raw);
1167 }
1168
1169 static void Emscripten_ApiResetUUID_Failed(unsigned handle, void *data_raw,
1170                                            int code, const char *status)
1171 {
1172   Error("server failed to handle request: %d %s", code, status);
1173
1174   FreeThreadData_ApiResetUUID(data_raw);
1175 }
1176
1177 static void Emscripten_ApiResetUUID_Progress(unsigned handle, void *data_raw,
1178                                              int bytes, int size)
1179 {
1180   // nothing to do here
1181 }
1182
1183 static void Emscripten_ApiResetUUID_HttpRequest(struct HttpRequest *request,
1184                                                 void *data_raw)
1185 {
1186   if (!SetRequest_ApiResetUUID(request, data_raw))
1187   {
1188     FreeThreadData_ApiResetUUID(data_raw);
1189
1190     return;
1191   }
1192
1193   emscripten_async_wget2_data(request->uri,
1194                               request->method,
1195                               request->body,
1196                               data_raw,
1197                               TRUE,
1198                               Emscripten_ApiResetUUID_Loaded,
1199                               Emscripten_ApiResetUUID_Failed,
1200                               Emscripten_ApiResetUUID_Progress);
1201 }
1202
1203 #else
1204
1205 static void ApiResetUUID_HttpRequestExt(struct HttpRequest *request,
1206                                         struct HttpResponse *response,
1207                                         void *data_raw)
1208 {
1209   if (!SetRequest_ApiResetUUID(request, data_raw))
1210     return;
1211
1212   if (!DoHttpRequest(request, response))
1213   {
1214     Error("HTTP request failed: %s", GetHttpError());
1215
1216     return;
1217   }
1218
1219   if (!HTTP_SUCCESS(response->status_code))
1220   {
1221     Error("server failed to handle request: %d %s",
1222           response->status_code,
1223           response->status_text);
1224
1225     return;
1226   }
1227
1228   HandleResponse_ApiResetUUID(response, data_raw);
1229 }
1230
1231 static void ApiResetUUID_HttpRequest(struct HttpRequest *request,
1232                                      struct HttpResponse *response,
1233                                      void *data_raw)
1234 {
1235   ApiResetUUID_HttpRequestExt(request, response, data_raw);
1236
1237   FreeThreadData_ApiResetUUID(data_raw);
1238 }
1239 #endif
1240
1241 static int ApiResetUUIDThread(void *data_raw)
1242 {
1243   struct HttpRequest *request = checked_calloc(sizeof(struct HttpRequest));
1244   struct HttpResponse *response = checked_calloc(sizeof(struct HttpResponse));
1245
1246   program.api_thread_count++;
1247
1248 #if defined(PLATFORM_EMSCRIPTEN)
1249   Emscripten_ApiResetUUID_HttpRequest(request, data_raw);
1250 #else
1251   ApiResetUUID_HttpRequest(request, response, data_raw);
1252 #endif
1253
1254   program.api_thread_count--;
1255
1256   checked_free(request);
1257   checked_free(response);
1258
1259   return 0;
1260 }
1261
1262 void ApiResetUUIDAsThread(char *uuid_new)
1263 {
1264   struct ApiResetUUIDThreadData *data = CreateThreadData_ApiResetUUID(uuid_new);
1265
1266   ExecuteAsThread(ApiResetUUIDThread,
1267                   "ApiResetUUID", data,
1268                   "reset UUID on server");
1269 }