以目的为驱动的开发实例

NanaS***

- 本文和Minecraft毫无关联。
- 本文涉及的语言为C。
- 项目地址：https://github.com/wxkj123/osu-utils，GPL V3 Licence

本文将详细叙述开发过程。

首先不要被结构如此复杂的源码吓到，其实本身是单文件，但是因为有些复杂，以及个人习惯问题导致单文件观感不佳，所以拆分成了这个样子。

然后安利一下这个游戏，叫osu!，没错是个音游。它是由社区驱动的，因此谱面文件都是由玩家制作并上传的。音乐嘛，有个很闹心的事情，就是会经常性地产生各种版权问题，osu!这里也不例外，那么问题就来了，打音游得听喜欢的歌，但是喜欢的歌往往又找不到，于是乎进入死循环，我根本不知道什么歌好听，找歌范围又过于宽泛，毫无目的性。

于是想了点办法，诶，别人打过的歌……应该……不会太难听吧，那可以照着别人的Best Play抄嘛（Best Play是直接挂在个人主页的）。

于是……就有了本项目。

这个程序是用来扒别人的Best Play的，当然也可以扒自己的。

想要扒这个东西，那就得要找到定位的抓手，即如何找到想要的谱面，这是其一；用什么下载，这是其二；用什么库，这是其三。解决好这几个问题，这个程序也就写出来了。

定位问题，随便打开一个谱面的info页，留心观察就会发现：



找到一个谱面需要有这两个数字，前者称作sid（即BeatmapSet ID），后者称作bid（Beatmap ID）。

那么获取这个数字就成了首要问题了。

既然音游群有机器人，曾经也问过某开发者适配问题，他是这么答的：



哦，有API啊，那好说，直接看文档就是了。



看来还有OAuth的问题。



挺好的，没什么难度。

因此批量获取谱面的方法是：先向API请求token，然后抓着这个token以及uid去问API要bplist，要到了之后，就可以从返回的json里面找到sid，然后下载。

选库方面，本来打算使用libuv+cJSON，后来发现我经验不够，uv根本不会，于是改用了libcurl+cJSON练手（其实也可以找借口说uv太重了）。

于是可以开始写了。

首先需要拿到token，那么这就是目标。首先请求完会拿到一个JSON文件，然后使用cJSON即可将token取出。

代码如下：

inc/util/OAuth.h：

1. #ifndef OAuth_h
   
2. #define OAuth_h
   
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. #include <time.h>
   
8. #include <curl/curl.h>
   
9. #include <sys/types.h>
   
10. #include <sys/stat.h>
    
11. #include <unistd.h>
    
12. #include "cJSON.h"
    
13. 
    
14. void read_token(char* tokenstring);
    
15. void on_token_expire(void);
    
16. void get_token(int clientid,const char* clientsec);
    
17. size_t token_cb(char* buffer,size_t size,size_t nitems,void* userdata);
    
18. 
    
19. #endif /* OAuth_h */
    

复制代码

src/core/auth/OAuth.c：

1. #include "OAuth.h"
   
2. 
   
3. void read_token(char* tokenstring){
   
4.     FILE* fp=fopen("Cache/token.json","r");
   
5.     int failcount=0;
   
6.     if(fp){
   
7.         fseek(fp,0,SEEK_END);
   
8.         long fsize=ftell(fp);
   
9.         if(fsize==0){
   
10.             on_token_expire();
    
11.             exit(-1);
    
12.         }
    
13.         fseek(fp,0,SEEK_SET);
    
14.         char ch;
    
15.         char* string=(char*) malloc(fsize);
    
16.         char* ptr=string;
    
17.         while(!feof(fp)){
    
18.             ch=fgetc(fp);
    
19.             * ptr++=ch;
    
20.         }
    
21.         fclose(fp);
    
22.         cJSON* root=cJSON_Parse(string);
    
23.         free(string);
    
24.         cJSON* timethen=cJSON_GetObjectItem(root,"time");
    
25.         time_t previous_time=timethen->valueint;
    
26.         time_t current_time=time(NULL);
    
27.         if(current_time-previous_time>=86400){
    
28.             on_token_expire();
    
29.             exit(-2);
    
30.         }
    
31.         cJSON* token=cJSON_GetObjectItem(root,"token");
    
32.         sprintf(tokenstring,"%s",token->valuestring);
    
33.         cJSON_Delete(root);
    
34.     }
    
35.     else{
    
36.         if(failcount>1){
    
37.             fprintf(stderr,"Failed to read and get token.\n");
    
38.         }
    
39.         on_token_expire();
    
40.         read_token(tokenstring);
    
41.     }
    
42. }
    
43. 
    
44. void on_token_expire(void){
    
45.     fprintf(stderr,"Failed to read token, will get another.\n");
    
46.     int clientid=5;
    
47.     char* clientsec="FGc9GAtyHzeQDshWP5Ah7dega8hJACAJpQtw6OXk";
    
48.     get_token(clientid,clientsec);
    
49. }
    
50. 
    
51. void get_token(int clientid,const char* clientsec){
    
52.     CURL* eh=curl_easy_init();
    
53.     if(eh){
    
54.         struct curl_slist* list;
    
55.         char data[114];
    
56.         sprintf(data,"client_id=%d&client_secret=%s&grant_type=client_credentials&scope=public",clientid,clientsec);
    
57.         list=curl_slist_append(NULL,"Accept: application/json");
    
58.         list=curl_slist_append(list,"Content-Type: application/x-www-form-urlencoded");
    
59.         curl_easy_setopt(eh,CURLOPT_URL,"https://osu.ppy.sh/oauth/token");
    
60.         curl_easy_setopt(eh,CURLOPT_PROXY,"http://localhost:7890");
    
61.         curl_easy_setopt(eh,CURLOPT_HTTPHEADER,list);
    
62.         curl_easy_setopt(eh,CURLOPT_POSTFIELDSIZE,(long)strlen(data));
    
63.         curl_easy_setopt(eh,CURLOPT_POSTFIELDS,data);
    
64.         curl_easy_setopt(eh,CURLOPT_TIMEOUT,30);
    
65.         curl_easy_setopt(eh,CURLOPT_WRITEFUNCTION,token_cb);
    
66.         curl_easy_perform(eh);
    
67.         curl_easy_cleanup(eh);
    
68.     }
    
69.     else{
    
70.         fprintf(stderr,"Failed to get token.\n");
    
71.         exit(1);
    
72.     }
    
73. }
    
74. 
    
75. size_t token_cb(char* buffer,size_t size,size_t nitems,void* userdata){
    
76.     FILE* read=(FILE*) userdata;
    
77.     size_t retcode=fread(buffer,size,nitems,read);
    
78.     cJSON* root=cJSON_Parse(buffer);
    
79.     cJSON* item=cJSON_GetObjectItem(root,"access_token");
    
80.     char* token=item->valuestring;
    
81.     time_t current=time(NULL);
    
82.     cJSON* data=cJSON_CreateObject();
    
83.     cJSON_AddNumberToObject(data,"time",current);
    
84.     cJSON_AddStringToObject(data,"token",token);
    
85.     char* jsondata=cJSON_Print(data);
    
86.     FILE* fp;
    
87.     fp=fopen("Cache/token.json","w+");
    
88.     fprintf(fp,"%s",jsondata);
    
89.     fclose(fp);
    
90.     cJSON_Delete(root);
    
91.     return retcode;
    
92. }

复制代码

oauth这个模块只做了一件事情，就是判断是否有token文件存在，如果有就读取，没有就再来一个。

token本身是有时效性的，如果token过期了，那就得重新请求，否则可以尽情复用，所以需要文件存储。

cJSON只是一个工具，C本身不具备解析JSON的功能，但是有了这个库后就有了。

请求完token就可以请求bplist，默认已知uid，查询范围。

代码如下：

inc/util/Getbplist.h：

1. #ifndef Getbplist
   
2. #define Getbplist
   
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. #include <curl/curl.h>
   
8. #include "cJSON.h"
   
9. 
   
10. #include "util/Basic.h"
    
11. #include "Mode.h"
    
12. 
    
13. void get_bplist(int uid,uint8_t mode_id,int offset,int limit,const char* token);
    
14. int* getsids(void);
    
15. 
    
16. #endif /* Getbplist_h */

复制代码

被Getbplist.h引用的inc/util/Basic.h：

1. #ifndef Basic_h
   
2. #define Basic_h
   
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. 
   
8. struct memory{
   
9.     char* response;
   
10.     size_t size;
    
11. };
    
12. 
    
13. size_t cb(char* buffer,size_t size,size_t nitems,void* userdata);
    
14. 
    
15. #endif /* Basic_h */

复制代码

1. inc/util/Mode.h：
   
2. 
   
3. #ifndef Mode_h
   
4. #define Mode_h
   
5. 
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. 
   
9. char* select_mode(uint8_t mode_id);
   
10. 
    
11. #endif /* Mode_h */

复制代码

src/core/network/Getbplist.c：

1. #include "Getbplist.h"
   
2. 
   
3. void get_bplist(int uid,uint8_t mode_id,int offset,int limit,const char* token){
   
4.     CURL* eh=curl_easy_init();
   
5.     if(eh){
   
6.         char* mode=select_mode(mode_id);
   
7.         char url[114];
   
8.         char oauth[1050];
   
9.         struct curl_slist* list;
   
10.         struct memory chunk={0};
    
11.         sprintf(url,"https://osu.ppy.sh/api/v2/users/%d/scores/best?include_fails=0&mode=%s&limit=%d&offset=%d",uid,mode,limit,offset);
    
12.         sprintf(oauth,"Authorization: Bearer %s",token);
    
13.         list=curl_slist_append(NULL,"Content-Type: application/json");
    
14.         list=curl_slist_append(list,"Accept: application/json");
    
15.         list=curl_slist_append(list,oauth);
    
16.         curl_easy_setopt(eh,CURLOPT_URL,url);
    
17.         curl_easy_setopt(eh,CURLOPT_HTTPHEADER,list);
    
18.         curl_easy_setopt(eh,CURLOPT_WRITEFUNCTION,cb);
    
19.         curl_easy_setopt(eh,CURLOPT_WRITEDATA,(void*) &chunk);
    
20.         curl_easy_setopt(eh,CURLOPT_TIMEOUT,30);
    
21.         curl_easy_perform(eh);
    
22.         
    
23.         // Write bplist to cache.
    
24.         
    
25.         FILE* fp;
    
26.         fp=fopen("Cache/bplist.json","w+");
    
27.         fprintf(fp,"%s",chunk.response);
    
28.         fclose(fp);
    
29.         
    
30.         free(chunk.response);
    
31.         curl_easy_cleanup(eh);
    
32.     }
    
33.     else{
    
34.         fprintf(stderr,"Failed to get bplist.\n");
    
35.     }
    
36. }
    
37. 
    
38. int* getsids(void){
    
39.     FILE* fp;
    
40.     fp=fopen("Cache/bplist.json","r");
    
41.     if(fp){
    
42.         fseek(fp,0,SEEK_END);
    
43.         long fsize=ftell(fp);
    
44.         if(fsize==0){
    
45.             exit(-1);
    
46.         }
    
47.         fseek(fp,0,SEEK_SET);
    
48.         char ch;
    
49.         char* string=malloc(fsize);
    
50.         char* ptr=string;
    
51.         while(!feof(fp)){
    
52.             ch=fgetc(fp);
    
53.             * ptr++=ch;
    
54.         }
    
55.         fclose(fp);
    
56.         cJSON* root=cJSON_Parse(string);
    
57.         int arraysize=cJSON_GetArraySize(root);
    
58.         cJSON* info;
    
59.         cJSON* beatmap;
    
60.         cJSON* siditem;
    
61.         int sid;
    
62.         int* array=(int*) malloc(arraysize*sizeof(int));
    
63.         for(int i=0;i<arraysize;i++){
    
64.             info=cJSON_GetArrayItem(root,i);
    
65.             beatmap=cJSON_GetObjectItem(info,"beatmap");
    
66.             siditem=cJSON_GetObjectItem(beatmap,"beatmapset_id");
    
67.             sid=siditem->valueint;
    
68.             array[i]=sid;
    
69.         }
    
70.         cJSON_Delete(root);
    
71.         return array;
    
72.     }
    
73.     else{
    
74.         fprintf(stderr,"Failed to get sids.\n");
    
75.         exit(-7);
    
76.     }
    
77. }

复制代码

src/core/network/Basic.c：

1. #include "Basic.h"
   
2. 
   
3. size_t cb(char* buffer,size_t size,size_t nitems,void* userdata){
   
4.     size_t realsize=size*nitems;
   
5.     struct memory *mem=(struct memory*) userdata;
   
6.     char* ptr=realloc(mem->response,mem->size+realsize+1);
   
7.     if(buffer==NULL){
   
8.         fprintf(stderr,"Out of memory.\n");
   
9.         exit(2);
   
10.     }
    
11.     mem->response=ptr;
    
12.     memcpy(&(mem->response[mem->size]),buffer,realsize);
    
13.     mem->size+=realsize;
    
14.     mem->response[mem->size]=0;
    
15.     return realsize;
    
16. }

复制代码

src/core/op/Mode.c：

1. #include "Mode.h"
   
2. 
   
3. char* select_mode(uint8_t mode_id){
   
4.     char* mode;
   
5.     switch(mode_id){
   
6.         case 0:
   
7.             mode="osu";
   
8.             break;
   
9.         case 1:
   
10.             mode="taiko";
    
11.             break;
    
12.         case 2:
    
13.             mode="fruits";
    
14.             break;
    
15.         case 3:
    
16.             mode="mania";
    
17.             break;
    
18.         default:
    
19.             fprintf(stderr,"Mode error.\n");
    
20.             exit(-4);
    
21.             break;
    
22.     }
    
23.     return mode;
    
24. }

复制代码

这里就是一个要注意的地方，因为libcurl的回调是基于TCP的，一次性可写不完，哪怕你说1MB不大吧，嗯，确实不大，但是就是不能一次写完。

事实上一次只能写1KB左右，那么就只能拿个容器接，什么容器呢，就是引入的Basic.h里面的那个memory结构，它就是容器。

回调执行完了之后，继续往下会发现一个事情，就是需要手工free这个chunk，即内存块，因为文件是一整块的，肯定不是什么分散的，所以很明显在free之前这个内存块都是可访问的，而且不需要在回调里面写向什么什么文件写什么数据，这是毫无必要的，因为在回调中写数据，执行一次回调就要写一次数据，那么比如说写1MB的数据，硬盘就被写了1000次，这硬盘可吃不消。那么接下来在free之前直接先把它catch住，直接朝文件里写就是了。

至于为什么要写Mode这个函数，因为0，1，2，3输入起来要比英文单词快，而且方便。

接下来最后一块就是要输出了，下载源方面，官方指定是靠不住了，为什么这么讲，因为这个csm是要靠JS去实现的，我觉得没什么必要，就麻烦一下国内的镜子吧:D。

本来下载是想要写成异步的，即所谓的多线程，但是后来一想，撑死了也就100个文件，慢又能慢到哪里去，于是就直接一个for循环结束了。

代码如下：

inc/util/Downloader.h：

1. #ifndef Downloader_h
   
2. #define Downloader_h
   
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. #include <time.h>
   
8. #include <curl/curl.h>
   
9. #include <sys/types.h>
   
10. #include <sys/stat.h>
    
11. #include <unistd.h>
    
12. 
    
13. #include "util/Basic.h"
    
14. 
    
15. int compare(const void* p1,const void* p2);
    
16. void mapdownloader(int* sids,int offset,int limit);
    
17. 
    
18. #endif /* Downloader_h */

复制代码

src/core/network/Downloader.c：

1. #include "Downloader.h"
   
2. 
   
3. int compare(const void* p1,const void* p2){
   
4.     return (*(int*) p1)-(*(int*) p2);
   
5. }
   
6. 
   
7. void mapdownloader(int* sids,int offset,int limit){
   
8.     struct stat st={0};
   
9.     if(stat("Mapsets",&st)==-1){
   
10.         mkdir("Mapsets",0755);
    
11.     }
    
12.     //To make life easier, sort the items before removing the duplicated.
    
13.     int j=1,count;
    
14.     qsort(sids,limit-offset,sizeof(int),compare);
    
15.     for(int i=1;i<limit-offset;i++){
    
16.         if(sids[i]!=sids[i-1]){
    
17.             sids[j++]=sids[i];
    
18.         }
    
19.     }
    
20.     count=j;
    
21.    
    
22.     // TODO: curl_multi
    
23.     // It's working well now. If needed, will do multi.
    
24.    
    
25.     CURL* downloader;
    
26.    
    
27.     for(int i=0;i<count;i++){
    
28.         downloader=curl_easy_init();
    
29.         if(downloader){
    
30.             struct memory chunk={0};
    
31.             char url[60];
    
32.             sprintf(url,"https://dl.sayobot.cn/beatmaps/download/full/%d",sids[i]);
    
33.             curl_easy_setopt(downloader,CURLOPT_URL,url);
    
34.             curl_easy_setopt(downloader,CURLOPT_FOLLOWLOCATION,1);
    
35.             curl_easy_setopt(downloader,CURLOPT_WRITEFUNCTION,cb);
    
36.             curl_easy_setopt(downloader,CURLOPT_WRITEDATA,(void*) &chunk);
    
37.             curl_easy_perform(downloader);
    
38.             FILE* fp;
    
39.             char fname[20];
    
40.             sprintf(fname,"Mapsets/%d.osz",sids[i]);
    
41.             fp=fopen(fname,"wb");
    
42.             fwrite(chunk.response,sizeof(char),chunk.size,fp);
    
43.             fclose(fp);
    
44.             free(chunk.response);
    
45.             curl_easy_cleanup(downloader);
    
46.         }
    
47.     }
    
48. }

复制代码

因为bplist里面会有重复，所以在下载之前需要对sid进行去重，这里选择先排序后去重，qsort()是C标准库函数。

这里这个程序就非常直白，我想做什么就都写进去了。

这就是目的驱动，我想做什么，都得先算计好，然后去写，这样才能写出一个像样的东西。

后期这个项目应该（？）还会更新，今天就写到这里了。

梦泽-M***

认真看完了，但是好像没看懂

Lei***

眼熟的代码