LiveParise/main.c

#include <cJSON.h>
#include <curl/curl.h>
#include <curl/easy.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define REGEN_ENC_URL_F(u, timestamp)                                                                                  \
    {                                                                                                                  \
        sprintf(u, ENC_URL, SUBROOMID, timestamp, SS);                                                                 \
    }

#define REGEN_URL_F(u, enc, timestamp)                                                                                 \
    {                                                                                                                  \
        sprintf(u, URL, SUBROOMID, enc, timestamp);                                                                    \
    }

#ifdef Debug
#define DPRINT(s, ...)                                                                                                 \
    {                                                                                                                  \
        printf(s, ...);                                                                                                \
    }
#else
#define DPRINT(s, ...)
#endif

struct memory
{
    char *response;
    size_t size;
};

CURLcode curl_get(const char *, struct memory *);
long long current_timestamp();
size_t cb(char *, size_t, size_t, void *);
char *get_enc();
void parise(void *);

const char ENC_URL[] = "https://lbapi-rk.chaoxing.com/lb/parise/enc/get?subRoomId=%s&timestamp=%llu&ss=%s";
const char URL[] = "https://zhibo.chaoxing.com/apis/live/setLivePariseCountByEnc?subroomId=%s&enc=%s&timestamp=%llu";
const char SUBROOMID[] = "381236458034402305";
const char SS[] = "381237373432790016";

int main(int argc, char *argv[])
{
    int thread;

    if (argc < 2)
        thread = 4;
    else
        thread = atoi(argv[1]);

    curl_global_init(CURL_GLOBAL_ALL);

    printf("线程\t状态\t点赞量\n");

    pthread_t **thread_pool = malloc(sizeof(pthread_t *) * thread);

    for (int i = 0; i < thread; i++)
    {
        thread_pool[i] = malloc(sizeof(pthread_t));
        pthread_create(thread_pool[i], NULL, (void *)&parise, (void *)i);
    }

    for (int i = 0; i < thread; i++)
    {
        pthread_join(*thread_pool[i], NULL);
    }

    curl_global_cleanup();

    for (int i = 0; i < 8; i++)
    {
        free(thread_pool[i]);
    }
    return 0;
}

CURLcode curl_get(const char *const url, struct memory *chunk)
{
    int status;
    CURL *curl = NULL;
    struct curl_slist *headers = NULL;

    curl = curl_easy_init();

    if (curl == NULL)
        return CURLE_FAILED_INIT;

    headers = curl_slist_append(headers, "Accept: application/json, text/javascript, */*; q=0.01");
    headers = curl_slist_append(headers, "User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like "
                                         "Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0");

    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_USE_SSL, true);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cb);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)chunk);

    status = curl_easy_perform(curl);
    if (status != CURLE_OK)
    {
        fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(status));
        exit(status);
    }

    curl_easy_cleanup(curl);
    curl_slist_free_all(headers);
    return status;
}

long long current_timestamp()
{
    time_t timestamp = time(NULL);
    return timestamp * 1000;
}

size_t cb(char *data, size_t size, size_t nmemb, void *clientp)
{
    size_t realsize = size * nmemb;
    struct memory *mem = (struct memory *)clientp;

    char *ptr = realloc(mem->response, mem->size + realsize + 1);
    if (!ptr)
        return 0; /* out of memory! */

    mem->response = ptr;
    memcpy(&(mem->response[mem->size]), data, realsize);
    mem->size += realsize;
    mem->response[mem->size] = 0;

    return realsize;
}

char *get_enc()
{
    char url[200];
    char *ret = NULL;
    struct memory data = {0};
    const cJSON *enc = NULL;

    REGEN_ENC_URL_F(url, current_timestamp());
    curl_get(url, &data);

    DPRINT("%s\n", data.response);

    cJSON *data_json = cJSON_Parse(data.response);
    enc = cJSON_GetObjectItemCaseSensitive(data_json, "enc");

    const size_t s = strlen(enc->valuestring);
    ret = malloc(s + 1);
    memcpy(ret, enc->valuestring, s + 1);

    free(data.response);
    cJSON_Delete(data_json);
    return ret;
}

// {'data': 293687, 'msg': '操作成功', 'result': 1}
void parise(void *arg)
{
    while (true)
    {
        char url[200];
        const int idx = (int)arg;
        struct memory json_c = {0};
        const char *enc = get_enc();
        const cJSON *result = NULL;
        const cJSON *msg = NULL;
        const cJSON *data = NULL;
        const cJSON *errorMsg = NULL;
        cJSON *json = NULL;

        REGEN_URL_F(url, enc, current_timestamp());
        curl_get(url, &json_c);

        json = cJSON_Parse(json_c.response);
        result = cJSON_GetObjectItemCaseSensitive(json, "result");
        msg = cJSON_GetObjectItemCaseSensitive(json, "msg");
        data = cJSON_GetObjectItemCaseSensitive(json, "data");
        errorMsg = cJSON_GetObjectItemCaseSensitive(json, "errorMsg");

        if (result->valueint == 1)
            printf("\rT%d\t%s\t%d", idx, msg->valuestring, data->valueint);
        else
            printf("\rT%d\t%s", idx, errorMsg->valuestring);
        fflush(stdout);

        free((void *)enc);
        free(json_c.response);

        cJSON_Delete(json);
    }
}