francesco/tgbot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: cleanup

Browse Source
This commit is contained in:
Francesco
2025-09-16 23:53:50 +02:00
parent 235c032062
commit c9af1429f9
13 changed files with 896 additions and 880 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.clangd
View File

@@ -1 +0,0 @@
HeaderInsertion: Never

101
examples/echobot/echobot.c
View File

@@ -1,52 +1,51 @@
#include <signal.h> #include <signal.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <tgbot.h> #include <tgbot.h>
bool run = true; bool run = true;
void sighandler(int signum) { void sighandler(int signum) {
run = false; run = false;
} }
void echo_message(tgbot *bot, tgbot_update *update) { void echo_message(tgbot_s *bot, tgbot_update_s *update) {
tgbot_send_message(bot, update->chat_id, update->text, "MARKDOWN", NULL); tgbot_send_message(bot, update->chat_id, update->text, "MARKDOWN", NULL);
} }
int main(void) { int main(void) {
/* Retrieve bot's token */ /* Retrieve bot's token */
FILE *fp = fopen(".token", "r"); FILE *fp = fopen(".token", "r");
if (fp == NULL) { if (fp == NULL) {
fprintf(stderr, "Unable to retrieve bot token\n"); fprintf(stderr, "Unable to retrieve bot token\n");
return 1; return 1;
} }
char token[256]; char token[256];
fscanf(fp, "%s", token); fscanf(fp, "%s", token);
fprintf(stdout, "Token: %s\n", token); fprintf(stdout, "Token: %s\n", token);
fclose(fp); fclose(fp);
signal(SIGINT, sighandler); signal(SIGINT, sighandler);
/* Initialize bot */ /* Initialize bot */
tgbot bot; tgbot_s *bot = tgbot_new(token);
tgbot_init(&bot, token); tgbot_update_s update;
tgbot_update update;
while (run) {
while (run) { tgbot_get_update(bot, &update, NULL);
tgbot_get_update(&bot, &update, NULL); if (strcmp(update.text, "/start") == 0) {
if (strcmp(update.text, "/start") == 0) { /* Send dice if /start otherwise echo the message */
/* Send dice if /start otherwise echo the message */ tgbot_send_dice(bot, update.chat_id, NULL);
tgbot_send_dice(&bot, update.chat_id, NULL); } else {
} else { echo_message(bot, &update);
echo_message(&bot, &update); }
} }
}
fprintf(stdout, "Closing...");
fprintf(stdout, "Closing..."); tgbot_free(bot);
tgbot_destroy(&bot);
return 0;
return 0;
} }

238
examples/inlinekeyboard/inlinekeyboard.c
View File

@@ -1,119 +1,119 @@
#include <signal.h> #include <signal.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <tgbot.h> #include <tgbot.h>
#define WELCOME_MSG "Hi there! This bot is coded in C." #define WELCOME_MSG "Hi there! This bot is coded in C."
void parse_command(tgbot *bot, tgbot_update *update); void parse_command(tgbot_s *bot, tgbot_update_s *update);
void sighandler(int signum); void sighandler(int signum);
void callback_parser(tgbot *bot, tgbot_cbquery *query); void callback_parser(tgbot_s *bot, tgbot_cbquery_s *query);
bool run = true; bool run = true;
tgbot bot; tgbot_s *bot;
tgbot_inlinekeyboard *keyboard; tgbot_inlinekeyboard_s *keyboard;
/* Callback handler function */ /* Callback handler function */
void callback_handler(tgbot *bot, tgbot_cbquery *query) { void callback_handler(tgbot_s *bot, tgbot_cbquery_s *query) {
if (strcmp("test-callback", query->data) == 0) { if (strcmp("test-callback", query->data) == 0) {
/* Handle `test-callback` */ /* Handle `test-callback` */
tgbot_inlinekeyboard *home_keyboard = tgbot_new_inlinekeyboard(1, 1); tgbot_inlinekeyboard_s *home_keyboard = tgbot_inlinekb_new(1, 1);
/* Add buttons */ /* Add buttons */
tgbot_inlinekeyboard_button(home_keyboard, 0, 0, "Home", "", "home"); tgbot_inlinekb_button(home_keyboard, 0, 0, "Home", "", "home");
tgbot_edit_message_text(bot, query->chat_id, query->message_id, "Callback called!", home_keyboard); tgbot_edit_message_text(bot, query->chat_id, query->message_id, "Callback called!", home_keyboard);
tgbot_destroy_inlinekeyboard(home_keyboard); tgbot_inlinekb_free(home_keyboard);
return; return;
} else if (strcmp("home", query->data) == 0) { } else if (strcmp("home", query->data) == 0) {
tgbot_edit_message_text(bot, query->chat_id, query->message_id, WELCOME_MSG, keyboard); tgbot_edit_message_text(bot, query->chat_id, query->message_id, WELCOME_MSG, keyboard);
return; return;
} }
} }
void sighandler(int signum) { void sighandler(int signum) {
fprintf(stdout, "Closing...\n"); fprintf(stdout, "Closing...\n");
run = false; run = false;
} }
void parse_command(tgbot *bot, tgbot_update *update) { void parse_command(tgbot_s *bot, tgbot_update_s *update) {
tgbot_rc ret; tgbot_rc ret;
if (strcmp("/start", update->text) == 0) { if (strcmp("/start", update->text) == 0) {
ret = tgbot_send_message(bot, update->chat_id, WELCOME_MSG, "Markdown", keyboard); ret = tgbot_send_message(bot, update->chat_id, WELCOME_MSG, "Markdown", keyboard);
if (ret != TGBOT_OK) { if (ret != TGBOT_OK) {
fprintf(stderr, "Failed to send message\n"); fprintf(stderr, "Failed to send message\n");
} }
return; return;
} }
/* Echo the message */ /* Echo the message */
ret = tgbot_send_message(bot, update->chat_id, update->text, "Markdown", NULL); ret = tgbot_send_message(bot, update->chat_id, update->text, "Markdown", NULL);
if (ret != TGBOT_OK) { if (ret != TGBOT_OK) {
fprintf(stderr, "Failed to send message\n"); fprintf(stderr, "Failed to send message\n");
} }
} }
int main(void) { int main(void) {
/* Find "your" way to free the resources */ /* Find "your" way to free the resources */
signal(SIGINT, sighandler); signal(SIGINT, sighandler);
tgbot_rc ret; tgbot_rc ret;
char token[256]; char token[256];
FILE *fp = fopen(".token", "r"); FILE *fp = fopen(".token", "r");
if (fp == NULL) { if (fp == NULL) {
fprintf(stderr, "No .token file found!\n"); fprintf(stderr, "No .token file found!\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
fscanf(fp, "%s", token); fscanf(fp, "%s", token);
fprintf(stdout, "Token: %s\n", token); fprintf(stdout, "Token: %s\n", token);
fclose(fp); fclose(fp);
/* Initialize the bot */ /* Initialize the bot */
ret = tgbot_init(&bot, token); bot = tgbot_new(token);
if (ret != TGBOT_OK) { if (!bot) {
fprintf(stderr, "tgbot_init()\n"); fprintf(stderr, "tgbot_init()\n");
exit(1); exit(1);
} }
/* Calling tgbot_get_me() you can get bot's info */ /* Calling tgbot_get_me() you can get bot's info */
fprintf(stdout, "Running Telegram bot...\nPress Ctrl-C to close.\n"); fprintf(stdout, "Running Telegram bot...\nPress Ctrl-C to close.\n");
tgbot_update update; tgbot_update_s update;
/* Allocate the new inline keyboard (remember to free!) */ /* Allocate the new inline keyboard (remember to free!) */
keyboard = tgbot_new_inlinekeyboard(1, 2); keyboard = tgbot_inlinekb_new(1, 2);
if (keyboard == NULL) { if (keyboard == NULL) {
tgbot_destroy(&bot); tgbot_free(bot);
return 1; return 1;
} }
/* Populate the InlineKeyboardMarkup */ /* Populate the InlineKeyboardMarkup */
tgbot_inlinekeyboard_button(keyboard, 0, 0, "Google", "https://google.com", ""); tgbot_inlinekb_button(keyboard, 0, 0, "Google", "https://google.com", "");
tgbot_inlinekeyboard_button(keyboard, 0, 1, "Callback", "", "test-callback"); tgbot_inlinekb_button(keyboard, 0, 1, "Callback", "", "test-callback");
/* If you want 3 buttons on 2 rows, for example on the first row 2 buttons and on the second only one */ /* If you want 3 buttons on 2 rows, for example on the first row 2 buttons and on the second only one */
/* you have to put rows = 2, columns = 2 and pass an empty string to .text field */ /* you have to put rows = 2, columns = 2 and pass an empty string to .text field */
/* Main loop */ /* Main loop */
while (run) { while (run) {
ret = tgbot_get_update(&bot, &update, callback_handler); ret = tgbot_get_update(bot, &update, callback_handler);
if (ret != TGBOT_OK) { if (ret != TGBOT_OK) {
fprintf(stderr, "tgbot_get_updates()\n"); fprintf(stderr, "tgbot_get_updates()\n");
continue; continue;
} }
if (update.message_id > 0) { if (update.message_id > 0) {
parse_command(&bot, &update); parse_command(bot, &update);
} }
} }
tgbot_destroy_inlinekeyboard(keyboard); tgbot_inlinekb_free(keyboard);
tgbot_destroy(&bot); tgbot_free(bot);
return 0; return 0;
} }

210
include/common.h
View File

@@ -1,102 +1,108 @@
#ifndef TGBOT_COMMON_H #ifndef TGBOT_COMMON_H
#define TGBOT_COMMON_H #define TGBOT_COMMON_H
#include <curl/curl.h> #include <curl/curl.h>
#include <stdint.h> #include <stdint.h>
/** #define TOKEN_SIZE 128
* @brief A structure used to get curl response. #define API_SIZE 512
*/
struct memory_buffer { #define FIRSTNAME_SIZE 256
char *data; #define USERNAME_SIZE 32
size_t size;
}; #define CHAT_LASTNAME_SIZE 256
#define CHAT_TYPE_SIZE 32
/** #define CHAT_TEXT_SIZE 4096
* @brief A structure to represent bot object.
*/ /**
struct tgbot_t { * @brief A structure used to get curl response.
char token[128]; /**< Bot token. */ */
char api[512]; /**< Bot API url. */ struct memory_buffer {
int32_t offset; /**< Bot offset. */ char *data;
}; size_t size;
typedef struct tgbot_t tgbot; };
/** /**
* @brief A structure to represent Bot information got from getMe API. * @brief A structure to represent bot object.
*/ */
struct tgbot_me_t { typedef struct tgbot {
char first_name[256]; /**< Bot's first name. */ char token[TOKEN_SIZE]; /**< Bot token. */
char username[32]; /**< Bot's username. */ char api[API_SIZE]; /**< Bot API url. */
}; int32_t offset; /**< Bot offset. */
typedef struct tgbot_me_t tgbot_me; } tgbot_s;
/** /**
* @brief A structure to represent Update object. * @brief A structure to represent Bot information got from getMe API.
*/ */
struct tgbot_update_t { typedef struct tgbot_me {
int64_t update_id; /**< Update id. */ char first_name[FIRSTNAME_SIZE]; /**< Bot's first name. */
long message_id; /**< Message id. */ char username[USERNAME_SIZE]; /**< Bot's username. */
int64_t chat_id; /**< Chat id. */ } tgbot_me_s;
char chat_first_name[256]; /**< Chat first name. */
char chat_last_name[256]; /**< Chat last name. */ /**
char chat_username[32]; /**< Chat username. */ * @brief A structure to represent Update object.
char chat_type[32]; /**< Chat type (private/public). */ */
int32_t date; /**< Date in unix timestamp. */ typedef struct tgbot_update {
char text[4096]; /**< Message text. */ int64_t update_id; /**< Update id. */
}; long message_id; /**< Message id. */
typedef struct tgbot_update_t tgbot_update; int64_t chat_id; /**< Chat id. */
char chat_first_name[FIRSTNAME_SIZE]; /**< Chat first name. */
/** char chat_last_name[CHAT_LASTNAME_SIZE]; /**< Chat last name. */
* @brief A structure to represent CallbackQuery object. char chat_username[USERNAME_SIZE]; /**< Chat username. */
*/ char chat_type[CHAT_TYPE_SIZE]; /**< Chat type (private/public). */
struct tgbot_cbquery_t { int32_t date; /**< Date in unix timestamp. */
int64_t update_id; char text[CHAT_TEXT_SIZE]; /**< Message text. */
long message_id; } tgbot_update_s;
int64_t chat_id;
char chat_username[32]; /**
int32_t date; * @brief A structure to represent CallbackQuery object.
char text[4096]; */
char chat_instance[128]; typedef struct tgbot_cbquery {
char data[64]; /**> Callback data. */ int64_t update_id;
}; long message_id;
typedef struct tgbot_cbquery_t tgbot_cbquery; int64_t chat_id;
char chat_username[USERNAME_SIZE];
/** int32_t date;
* @brief Callback function pointer. char text[CHAT_TEXT_SIZE];
*/ char chat_instance[128];
typedef void (*Callback)(tgbot *bot, tgbot_cbquery *query); char data[64]; /**> Callback data. */
} tgbot_cbquery_s;
/**
* @brief An enum to represent error codes. /**
*/ * @brief Callback function pointer.
enum tgbot_rc_t { */
TGBOT_OK = 0, typedef void (*Callback)(tgbot_s *bot, tgbot_cbquery_s *query);
TGBOT_INIT_ERROR,
TGBOT_REQUEST_ERROR, /**
TGBOT_GETUPDATES_ERROR, * @brief An enum to represent error codes.
TGBOT_GETME_ERROR, */
TGBOT_SENDMESSAGE_ERROR, enum tgbot_rc_t {
TGBOT_EDITMESSAGETEXT_ERROR, TGBOT_OK = 0,
TGBOT_SENDDICE_ERROR, TGBOT_INIT_ERROR,
TGBOT_TELEGRAM_OK_ERROR, TGBOT_REQUEST_ERROR,
}; TGBOT_GETUPDATES_ERROR,
typedef enum tgbot_rc_t tgbot_rc; TGBOT_GETME_ERROR,
TGBOT_SENDMESSAGE_ERROR,
enum tgbot_json_opt_type_t { TGBOT_EDITMESSAGETEXT_ERROR,
tgbot_opt_int, TGBOT_SENDDICE_ERROR,
tgbot_opt_int64, TGBOT_TELEGRAM_OK_ERROR,
tgbot_opt_string, };
tgbot_opt_inlinekeyboard, typedef enum tgbot_rc_t tgbot_rc;
tgbot_opt_null,
}; enum tgbot_json_opt_type_t {
typedef enum tgbot_json_opt_type_t tgbot_json_opt_type; tgbot_opt_int,
tgbot_opt_int64,
struct tgbot_json_option_t { tgbot_opt_string,
char key[32]; tgbot_opt_inlinekeyboard,
void *value; tgbot_opt_null,
tgbot_json_opt_type type; };
}; typedef enum tgbot_json_opt_type_t tgbot_json_opt_type;
typedef struct tgbot_json_option_t tgbot_json_option;
struct tgbot_json_option_t {
#endif char key[32];
void *value;
tgbot_json_opt_type type;
};
typedef struct tgbot_json_option_t tgbot_json_option;
#endif

21
include/json.h
View File

@@ -1,10 +1,11 @@
#ifndef TGBOT_JSON_H #ifndef TGBOT_JSON_H
#define TGBOT_JSON_H #define TGBOT_JSON_H
#include "types.h" #include "types.h"
#include <json-c/json.h> #include <json-c/json.h>
json_object *tgbot_json_builder(tgbot_json_option *options, size_t optionslen); json_object *json_builder(tgbot_json_option *options, size_t optionslen);
json_object *tgbot_new_inlinekeyboardmarkup(tgbot_inlinekeyboard *keyboard);
json_object *json_ikb_new(tgbot_inlinekeyboard_s *keyboard);
#endif
#endif

46
include/methods.h
View File

@@ -1,23 +1,23 @@
#ifndef TGBOT_METHODS_H #ifndef TGBOT_METHODS_H
#define TGBOT_METHODS_H #define TGBOT_METHODS_H
#include "types.h" #include "types.h"
#include <json-c/json.h> #include <json-c/json.h>
tgbot_rc tgbot_get_update(tgbot *bot, tgbot_update *update, Callback cbq_handler); tgbot_rc tgbot_get_update(tgbot_s *bot, tgbot_update_s *update, Callback cbq_handler);
tgbot_rc tgbot_parse_message(tgbot *bot, tgbot_update *update, json_object *result); tgbot_rc tgbot_parse_message(tgbot_s *bot, tgbot_update_s *update, json_object *result);
tgbot_rc tgbot_parse_cbquery(tgbot *bot, tgbot_cbquery *query, json_object *result, Callback query_handler); tgbot_rc tgbot_parse_cbquery(tgbot_s *bot, tgbot_cbquery_s *query, json_object *result, Callback query_handler);
/* Request */ /* Request */
size_t write_callback(void *ptr, size_t size, size_t nmemb, char **userdata); size_t write_callback(void *ptr, size_t size, size_t nmemb, char **userdata);
tgbot_rc tgbot_request(const char *url, struct memory_buffer **mb, json_object *json); tgbot_rc tgbot_request(const char *url, struct memory_buffer **mb, json_object *json);
/* Methods */ /* Methods */
tgbot_rc tgbot_get_me(tgbot *bot, tgbot_me *me); tgbot_rc tgbot_get_me(tgbot_s *bot, tgbot_me_s *me);
tgbot_rc tgbot_send_message(tgbot *bot, int64_t chat_id, const char *text, const char *parse_mode, tgbot_inlinekeyboard *reply_markup); tgbot_rc tgbot_send_message(tgbot_s *bot, int64_t chat_id, const char *text, const char *parse_mode, tgbot_inlinekeyboard_s *reply_markup);
tgbot_rc tgbot_send_dice(tgbot *bot, int64_t chat_id, const char *emoji); tgbot_rc tgbot_send_dice(tgbot_s *bot, int64_t chat_id, const char *emoji);
/* Updating Methods */ /* Updating Methods */
tgbot_rc tgbot_edit_message_text(tgbot *bot, int64_t chat_id, long message_id, const char *text, tgbot_inlinekeyboard *keyboard); tgbot_rc tgbot_edit_message_text(tgbot_s *bot, int64_t chat_id, long message_id, const char *text, tgbot_inlinekeyboard_s *keyboard);
#endif #endif

49
include/tgbot.h
View File

@@ -1,25 +1,24 @@
#ifndef TGBOT_MAIN_H #ifndef TGBOT_MAIN_H
#define TGBOT_MAIN_H #define TGBOT_MAIN_H
#include "common.h" #include "common.h"
#include "methods.h" #include "methods.h"
#include "types.h" #include "types.h"
/** /**
* @brief Initializes the Bot object. * @brief Create a new Bot object.
* *
* @param[out] bot The Bot object. * @param[in] token The Bot token (obtained from @BotFather).
* @param[in] token The Bot token (obtained from @BotFather). *
* * @return Bot pointer.
* @return TGBOT_OK on success. */
*/ tgbot_s *tgbot_new(char *token);
tgbot_rc tgbot_init(tgbot *bot, char *token);
/**
/** * @brief Cleans the memory.
* @brief Cleans the memory. *
* * @param[out] bot The Bot object.
* @param[out] bot The Bot object. */
*/ void tgbot_free(tgbot_s *bot);
void tgbot_destroy(tgbot *bot);
#endif // TGBOT_H
#endif // TGBOT_H

138
include/types.h
View File

@@ -1,68 +1,70 @@
#ifndef TGBOT_TYPES_H #ifndef TGBOT_TYPES_H
#define TGBOT_TYPES_H #define TGBOT_TYPES_H
#include "common.h" #include "common.h"
/** #define TEXT_SIZE 200
* @brief Represents a single button on an inline keyboard. #define URL_SIZE 200
*/ #define CB_DATA_SIZE 64
struct tgbot_inlinekeyboardbutton_t {
char text[200]; /**< Text of the button. If empty, the button is ignored. */ /**
char url[200]; /**< (Optional) URL to be opened when the button is pressed. */ * @brief Represents a single button on an inline keyboard.
char callback_data[64]; /**< (Optional) Data sent to the bot when the button is pressed. */ */
}; typedef struct tgbot_inlinekeyboardbutton {
typedef struct tgbot_inlinekeyboardbutton_t tgbot_inlinekeyboardbutton; char text[TEXT_SIZE]; /**< Text of the button. If empty, the button is ignored. */
char url[URL_SIZE]; /**< (Optional) URL to be opened when the button is pressed. */
/** char callback_data[CB_DATA_SIZE]; /**< (Optional) Data sent to the bot when the button is pressed. */
* @brief Represents an inline keyboard. } tgbot_inlinekeyboardbutton_s;
*/
struct tgbot_inlinekeyboard_t { /**
size_t rows; /**< Number of rows in the keyboard. */ * @brief Represents an inline keyboard.
size_t columns; /**< Number of columns per row. */ */
struct tgbot_inlinekeyboardbutton_t *buttons; /**< Array of buttons. */ typedef struct tgbot_inlinekeyboard {
}; size_t rows; /**< Number of rows in the keyboard. */
typedef struct tgbot_inlinekeyboard_t tgbot_inlinekeyboard; size_t columns; /**< Number of columns per row. */
tgbot_inlinekeyboardbutton_s *buttons; /**< Array of buttons. */
/** } tgbot_inlinekeyboard_s;
* @brief Allocates a new inline keyboard.
* /**
* @param[in] rows Number of rows in the keyboard. * @brief Allocates a new inline keyboard.
* @param[in] columns Number of columns in each row. *
* * @param[in] rows Number of rows in the keyboard.
* @return The pointer to the keyboard or NULL on allocation failure. * @param[in] columns Number of columns in each row.
*/ *
tgbot_inlinekeyboard *tgbot_new_inlinekeyboard(size_t rows, size_t columns); * @return The pointer to the keyboard or NULL on allocation failure.
*/
/** tgbot_inlinekeyboard_s *tgbot_inlinekb_new(size_t rows, size_t columns);
* @brief Adds or updates a button at the specified position in the keyboard.
* /**
* @param[out] keyboard Pointer to the keyboard to modify. * @brief Adds or updates a button at the specified position in the keyboard.
* @param[in] row Row index of the button (starting from 0). *
* @param[in] column Column index of the button (starting from 0). * @param[out] keyboard Pointer to the keyboard to modify.
* @param[in] text Display text for the button. * @param[in] row Row index of the button (starting from 0).
* @param[in] url Optional URL for the button. * @param[in] column Column index of the button (starting from 0).
* @param[in] callback_data Optional callback data for the button. * @param[in] text Display text for the button.
* * @param[in] url Optional URL for the button.
* @return TGBOT_OK on success. * @param[in] callback_data Optional callback data for the button.
*/ *
tgbot_rc tgbot_inlinekeyboard_button(tgbot_inlinekeyboard *keyboard, size_t row, size_t column, const char *text, const char *url, const char *callback_data); * @return TGBOT_OK on success.
*/
/** tgbot_rc tgbot_inlinekb_button(tgbot_inlinekeyboard_s *keyboard, size_t row, size_t column, const char *text, const char *url, const char *callback_data);
* @brief Returns a pointer to the keyboard's button.
* /**
* @param[in] keyboard Keyboard. * @brief Returns a pointer to the keyboard's button.
* @param[in] row Row index of the button. *
* @param[in] column Column index of the button. * @param[in] keyboard Keyboard.
* * @param[in] row Row index of the button.
* @return Pointer to the button, or NULL if the position is invalid. * @param[in] column Column index of the button.
*/ *
tgbot_inlinekeyboardbutton *tgbot_inlinekeyboard_button_at(tgbot_inlinekeyboard *keyboard, size_t row, size_t column); * @return Pointer to the button, or NULL if the position is invalid.
*/
/** tgbot_inlinekeyboardbutton_s *tgbot_inlinekb_button_at(tgbot_inlinekeyboard_s *keyboard, size_t row, size_t column);
* @brief Frees all memory associated with the given inline keyboard.
* /**
* @param[in,out] keyboard Pointer to the keyboard structure to deallocate. * @brief Frees all memory associated with the given inline keyboard.
*/ *
void tgbot_destroy_inlinekeyboard(tgbot_inlinekeyboard *keyboard); * @param[in,out] keyboard Pointer to the keyboard structure to deallocate.
*/
#endif void tgbot_inlinekb_free(tgbot_inlinekeyboard_s *keyboard);
#endif

65
meson.build
View File

@@ -1,30 +1,35 @@
project('tgbot', 'c', version: '0.1') project(
'tgbot',
sources = [] 'c',
subdir('src') version: '0.1',
default_options: ['warning_level=3', 'c_std=c18'],
inc_dir = include_directories('include') )
curl_dep = dependency('libcurl') sources = []
json_c_dep = dependency('json-c') subdir('src')
deps = [curl_dep, json_c_dep] inc_dir = include_directories('include')
install_headers('include/tgbot.h') curl_dep = dependency('libcurl')
json_c_dep = dependency('json-c')
tgbot_lib = library(
'tgbot', deps = [curl_dep, json_c_dep]
sources,
dependencies: deps, install_headers('include/tgbot.h')
include_directories: inc_dir,
install: true, tgbot_lib = library(
) 'tgbot',
sources,
# Example (windows) dependencies: deps,
executable( include_directories: inc_dir,
'example', install: true,
'examples/echobot/echobot.c', )
dependencies: deps,
link_with: tgbot_lib, # Example (windows)
include_directories: inc_dir, executable(
) 'example',
'examples/echobot/echobot.c',
dependencies: deps,
link_with: tgbot_lib,
include_directories: inc_dir,
)

112
src/json.c
View File

@@ -1,56 +1,56 @@
#include <string.h> #include <string.h>
#include "json.h" #include "json.h"
json_object *tgbot_json_builder(tgbot_json_option *options, size_t optionslen) { json_object *json_builder(tgbot_json_option *options, size_t optionslen) {
json_object *rjson = json_object_new_object(); json_object *rjson = json_object_new_object();
for (size_t i = 0; i < optionslen; ++i) { for (size_t i = 0; i < optionslen; ++i) {
if (options[i].type == tgbot_opt_int) { if (options[i].type == tgbot_opt_int) {
json_object_object_add(rjson, options[i].key, json_object_new_int(*((int32_t *)options[i].value))); json_object_object_add(rjson, options[i].key, json_object_new_int(*((int32_t *)options[i].value)));
} else if (options[i].type == tgbot_opt_string) { } else if (options[i].type == tgbot_opt_string) {
if (!options[i].value) { if (!options[i].value) {
continue; continue;
} }
json_object_object_add(rjson, options[i].key, json_object_new_string((char *)options[i].value)); json_object_object_add(rjson, options[i].key, json_object_new_string((char *)options[i].value));
} else if (options[i].type == tgbot_opt_int64) { } else if (options[i].type == tgbot_opt_int64) {
json_object_object_add(rjson, options[i].key, json_object_new_int64(*((int64_t *)options[i].value))); json_object_object_add(rjson, options[i].key, json_object_new_int64(*((int64_t *)options[i].value)));
} else if (options[i].type == tgbot_opt_inlinekeyboard) { } else if (options[i].type == tgbot_opt_inlinekeyboard) {
if (options[i].value != NULL) { if (options[i].value != NULL) {
json_object *reply_markup = tgbot_new_inlinekeyboardmarkup((tgbot_inlinekeyboard *)options[i].value); json_object *reply_markup = json_ikb_new((tgbot_inlinekeyboard_s *)options[i].value);
json_object_object_add(rjson, "reply_markup", reply_markup); json_object_object_add(rjson, "reply_markup", reply_markup);
} }
} else if (options[i].type == tgbot_opt_null) { } else if (options[i].type == tgbot_opt_null) {
continue; continue;
} }
} }
return rjson; return rjson;
} }
json_object *tgbot_new_inlinekeyboardmarkup(tgbot_inlinekeyboard *keyboard) { json_object *json_ikb_new(tgbot_inlinekeyboard_s *keyboard) {
json_object *reply_markup = json_object_new_object(); json_object *reply_markup = json_object_new_object();
json_object *inline_keyboard_array = json_object_new_array(); json_object *inline_keyboard_array = json_object_new_array();
for (size_t i = 0; i < keyboard->rows; ++i) { for (size_t i = 0; i < keyboard->rows; ++i) {
json_object *row = json_object_new_array(); json_object *row = json_object_new_array();
for (size_t j = 0; j < keyboard->columns; ++j) { for (size_t j = 0; j < keyboard->columns; ++j) {
tgbot_inlinekeyboardbutton *kbbutton = tgbot_inlinekeyboard_button_at(keyboard, i, j); tgbot_inlinekeyboardbutton_s *kbbutton = tgbot_inlinekb_button_at(keyboard, i, j);
if (strcmp(kbbutton->text, "") == 0) { if (strcmp(kbbutton->text, "") == 0) {
continue; continue;
} }
json_object *button = json_object_new_object(); json_object *button = json_object_new_object();
json_object_object_add(button, "text", json_object_new_string(kbbutton->text)); json_object_object_add(button, "text", json_object_new_string(kbbutton->text));
json_object_object_add(button, "url", json_object_new_string(kbbutton->url)); json_object_object_add(button, "url", json_object_new_string(kbbutton->url));
json_object_object_add(button, "callback_data", json_object_new_string(kbbutton->callback_data)); json_object_object_add(button, "callback_data", json_object_new_string(kbbutton->callback_data));
json_object_array_add(row, button); json_object_array_add(row, button);
} }
json_object_array_add(inline_keyboard_array, row); json_object_array_add(inline_keyboard_array, row);
} }
json_object_object_add(reply_markup, "inline_keyboard", inline_keyboard_array); json_object_object_add(reply_markup, "inline_keyboard", inline_keyboard_array);
return reply_markup; return reply_markup;
} }

667
src/methods.c
View File

@@ -1,334 +1,333 @@
#include <curl/curl.h> #include <curl/curl.h>
#include <string.h> #include <string.h>
#include "json.h" #include "json.h"
#include "methods.h" #include "methods.h"
tgbot_rc tgbot_get_update(tgbot *bot, tgbot_update *update, Callback cbq_handler) { tgbot_rc tgbot_get_update(tgbot_s *bot, tgbot_update_s *update, Callback cbq_handler) {
char url[1024]; char url[1024];
/* Clear Update */ memset(update, 0, sizeof(tgbot_update_s));
memset(update, 0, sizeof(tgbot_update));
int limit = 1;
int limit = 1; int timeout = 30;
int timeout = 30; tgbot_json_option options[3] = {
tgbot_json_option options[3] = { {"offset", &bot->offset, tgbot_opt_int64},
{"offset", &bot->offset, tgbot_opt_int64}, {"limit", &limit, tgbot_opt_int},
{"limit", &limit, tgbot_opt_int}, {"timeout", &timeout, tgbot_opt_int},
{"timeout", &timeout, tgbot_opt_int}, };
}; json_object *rjson = json_builder(options, 3);
json_object *rjson = tgbot_json_builder(options, 3);
snprintf(url, sizeof(url), "%sgetUpdates", bot->api);
snprintf(url, sizeof(url), "%sgetUpdates", bot->api);
struct memory_buffer *mb;
struct memory_buffer *mb; tgbot_rc ret = tgbot_request(url, &mb, rjson);
tgbot_rc ret = tgbot_request(url, &mb, rjson); json_object_put(rjson);
json_object_put(rjson); if (ret != TGBOT_OK) {
if (ret != TGBOT_OK) { free(mb->data);
free(mb->data); free(mb);
free(mb);
return TGBOT_GETUPDATES_ERROR;
return TGBOT_GETUPDATES_ERROR; }
}
json_object *json = json_tokener_parse(mb->data);
json_object *json = json_tokener_parse(mb->data); free(mb->data);
free(mb->data); free(mb);
free(mb);
json_object *ok = json_object_object_get(json, "ok");
json_object *ok = json_object_object_get(json, "ok"); if (!json_object_is_type(ok, json_type_boolean) || !json_object_get_boolean(ok)) {
if (!json_object_is_type(ok, json_type_boolean) || !json_object_get_boolean(ok)) { json_object_put(json);
json_object_put(json);
return TGBOT_TELEGRAM_OK_ERROR;
return TGBOT_TELEGRAM_OK_ERROR; }
}
json_object *results = json_object_object_get(json, "result");
json_object *results = json_object_object_get(json, "result"); size_t results_len = json_object_array_length(results);
size_t results_len = json_object_array_length(results);
if (results_len == 0) {
if (results_len == 0) { json_object_put(json);
json_object_put(json);
return TGBOT_OK;
return TGBOT_OK; }
}
/* Check if it is a Message or a CallbackQuery*/
/* Check if it is a Message or a CallbackQuery*/ json_object *result = json_object_array_get_idx(results, 0);
json_object *result = json_object_array_get_idx(results, 0); json_object *message = json_object_object_get(result, "message");
json_object *message = json_object_object_get(result, "message"); if (message) {
if (message) { tgbot_parse_message(bot, update, result);
tgbot_parse_message(bot, update, result); } else if (cbq_handler != NULL) {
} else if (cbq_handler != NULL) { tgbot_cbquery_s query;
tgbot_cbquery query; tgbot_parse_cbquery(bot, &query, result, cbq_handler);
tgbot_parse_cbquery(bot, &query, result, cbq_handler); }
}
json_object_put(json);
json_object_put(json);
return TGBOT_OK;
return TGBOT_OK; }
}
tgbot_rc tgbot_parse_message(tgbot_s *bot, tgbot_update_s *update, json_object *result) {
tgbot_rc tgbot_parse_message(tgbot *bot, tgbot_update *update, json_object *result) { json_object *update_id = json_object_object_get(result, "update_id");
json_object *update_id = json_object_object_get(result, "update_id"); bot->offset = json_object_get_int(update_id) + 1;
bot->offset = json_object_get_int(update_id) + 1; update->update_id = json_object_get_int(update_id);
update->update_id = json_object_get_int(update_id);
json_object *message = json_object_object_get(result, "message");
json_object *message = json_object_object_get(result, "message"); json_object *message_id = json_object_object_get(message, "message_id");
json_object *message_id = json_object_object_get(message, "message_id"); if (message_id) {
if (message_id) { update->message_id = json_object_get_int(message_id);
update->message_id = json_object_get_int(message_id); }
}
json_object *chat = json_object_object_get(message, "chat");
json_object *chat = json_object_object_get(message, "chat"); json_object *chat_id = json_object_object_get(chat, "id");
json_object *chat_id = json_object_object_get(chat, "id"); if (chat_id) {
if (chat_id) { update->chat_id = json_object_get_int64(chat_id);
update->chat_id = json_object_get_int64(chat_id); }
}
json_object *chat_first_name = json_object_object_get(chat, "first_name");
json_object *chat_first_name = json_object_object_get(chat, "first_name"); if (chat_first_name) {
if (chat_first_name) { strncpy(update->chat_first_name, json_object_get_string(chat_first_name), sizeof(update->chat_first_name) - 1);
strncpy(update->chat_first_name, json_object_get_string(chat_first_name), sizeof(update->chat_first_name) - 1); }
}
json_object *chat_last_name = json_object_object_get(chat, "last_name");
json_object *chat_last_name = json_object_object_get(chat, "last_name"); if (chat_last_name) {
if (chat_last_name) { strncpy(update->chat_last_name, json_object_get_string(chat_last_name), sizeof(update->chat_last_name) - 1);
strncpy(update->chat_last_name, json_object_get_string(chat_last_name), sizeof(update->chat_last_name) - 1); }
}
json_object *chat_username = json_object_object_get(chat, "username");
json_object *chat_username = json_object_object_get(chat, "username"); if (chat_username != NULL) {
if (chat_username != NULL) { strncpy(update->chat_username, json_object_get_string(chat_username), sizeof(update->chat_username) - 1);
strncpy(update->chat_username, json_object_get_string(chat_username), sizeof(update->chat_username) - 1); }
}
json_object *chat_type = json_object_object_get(chat, "type");
json_object *chat_type = json_object_object_get(chat, "type"); if (chat_type) {
if (chat_type) { strncpy(update->chat_type, json_object_get_string(chat_type), sizeof(update->chat_type) - 1);
strncpy(update->chat_type, json_object_get_string(chat_type), sizeof(update->chat_type) - 1); }
}
json_object *date = json_object_object_get(message, "date");
json_object *date = json_object_object_get(message, "date"); if (date) {
if (date) { update->date = json_object_get_int(date);
update->date = json_object_get_int(date); }
}
json_object *text = json_object_object_get(message, "text");
json_object *text = json_object_object_get(message, "text"); if (text) {
if (text) { strncpy(update->text, json_object_get_string(text), sizeof(update->text) - 1);
strncpy(update->text, json_object_get_string(text), sizeof(update->text) - 1); }
}
return TGBOT_OK;
return TGBOT_OK; }
}
tgbot_rc tgbot_parse_cbquery(tgbot_s *bot, tgbot_cbquery_s *query, json_object *result, Callback cbq_handler) {
tgbot_rc tgbot_parse_cbquery(tgbot *bot, tgbot_cbquery *query, json_object *result, Callback cbq_handler) { json_object *update_id = json_object_object_get(result, "update_id");
json_object *update_id = json_object_object_get(result, "update_id"); bot->offset = json_object_get_int(update_id) + 1;
bot->offset = json_object_get_int(update_id) + 1; query->update_id = json_object_get_int(update_id);
query->update_id = json_object_get_int(update_id);
json_object *callback_query = json_object_object_get(result, "callback_query");
json_object *callback_query = json_object_object_get(result, "callback_query"); json_object *message = json_object_object_get(callback_query, "message");
json_object *message = json_object_object_get(callback_query, "message"); json_object *message_id = json_object_object_get(message, "message_id");
json_object *message_id = json_object_object_get(message, "message_id"); if (message_id) {
if (message_id) { query->message_id = json_object_get_int(message_id);
query->message_id = json_object_get_int(message_id); }
}
json_object *chat = json_object_object_get(message, "chat");
json_object *chat = json_object_object_get(message, "chat"); json_object *chat_id = json_object_object_get(chat, "id");
json_object *chat_id = json_object_object_get(chat, "id"); if (chat_id) {
if (chat_id) { query->chat_id = json_object_get_int64(chat_id);
query->chat_id = json_object_get_int64(chat_id); }
}
json_object *chat_username = json_object_object_get(chat, "username");
json_object *chat_username = json_object_object_get(chat, "username"); if (chat_username) {
if (chat_username) { strncpy(query->chat_username, json_object_get_string(chat_username), sizeof(query->chat_username) - 1);
strncpy(query->chat_username, json_object_get_string(chat_username), sizeof(query->chat_username) - 1); }
}
json_object *date = json_object_object_get(message, "date");
json_object *date = json_object_object_get(message, "date"); if (date) {
if (date) { query->date = json_object_get_int(date);
query->date = json_object_get_int(date); }
}
json_object *text = json_object_object_get(message, "text");
json_object *text = json_object_object_get(message, "text"); if (text) {
if (text) { strncpy(query->text, json_object_get_string(text), sizeof(query->text) - 1);
strncpy(query->text, json_object_get_string(text), sizeof(query->text) - 1); }
}
json_object *chat_instance = json_object_object_get(callback_query, "chat_instance");
json_object *chat_instance = json_object_object_get(callback_query, "chat_instance"); if (chat_instance) {
if (chat_instance) { strncpy(query->chat_instance, json_object_get_string(chat_instance), sizeof(query->chat_instance) - 1);
strncpy(query->chat_instance, json_object_get_string(chat_instance), sizeof(query->chat_instance) - 1); }
}
json_object *data = json_object_object_get(callback_query, "data");
json_object *data = json_object_object_get(callback_query, "data"); if (data) {
if (data) { strncpy(query->data, json_object_get_string(data), sizeof(query->data) - 1);
strncpy(query->data, json_object_get_string(data), sizeof(query->data) - 1); }
}
cbq_handler(bot, query);
cbq_handler(bot, query);
return TGBOT_OK;
return TGBOT_OK; }
}
size_t write_callback(void *ptr, size_t size, size_t nmemb, char **userdata) {
size_t write_callback(void *ptr, size_t size, size_t nmemb, char **userdata) { size_t real_size = size * nmemb;
size_t real_size = size * nmemb; struct memory_buffer *mem = (struct memory_buffer *)userdata;
struct memory_buffer *mem = (struct memory_buffer *)userdata;
mem->data = realloc(mem->data, mem->size + real_size + 1);
mem->data = realloc(mem->data, mem->size + real_size + 1); memcpy(&(mem->data[mem->size]), ptr, real_size);
memcpy(&(mem->data[mem->size]), ptr, real_size); mem->size += real_size;
mem->size += real_size; mem->data[mem->size] = '\0';
mem->data[mem->size] = '\0';
return real_size;
return real_size; }
}
size_t discard_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
size_t discard_callback(char *ptr, size_t size, size_t nmemb, void *userdata) { return size * nmemb;
return size * nmemb; }
}
tgbot_rc tgbot_request(const char *url, struct memory_buffer **mb, json_object *json) {
tgbot_rc tgbot_request(const char *url, struct memory_buffer **mb, json_object *json) { CURL *curl = curl_easy_init();
CURL *curl = curl_easy_init(); if (!curl) {
if (!curl) { return TGBOT_REQUEST_ERROR;
return TGBOT_REQUEST_ERROR; }
}
const char *json_string = NULL;
const char *json_string = NULL;
struct curl_slist *headers = NULL;
struct curl_slist *headers = NULL; headers = curl_slist_append(headers, "Accept: application/json");
headers = curl_slist_append(headers, "Accept: application/json"); headers = curl_slist_append(headers, "Content-Type: application/json");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_URL, url); curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
if (mb != NULL) {
if (mb != NULL) { *mb = calloc(1, sizeof(struct memory_buffer));
*mb = calloc(1, sizeof(struct memory_buffer)); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)write_callback);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)write_callback); curl_easy_setopt(curl, CURLOPT_WRITEDATA, *mb);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, *mb); } else {
} else { curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, discard_callback);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, discard_callback); curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL); }
}
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L); curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 30L);
curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 30L);
if (json != NULL) {
if (json != NULL) { json_string = json_object_to_json_string_ext(json, JSON_C_TO_STRING_PLAIN);
json_string = json_object_to_json_string_ext(json, JSON_C_TO_STRING_PLAIN); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_string);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_string); }
}
CURLcode res = curl_easy_perform(curl);
CURLcode res = curl_easy_perform(curl);
curl_slist_free_all(headers);
curl_slist_free_all(headers);
if (res != CURLE_OK) {
if (res != CURLE_OK) { if (mb != NULL && *mb) {
if (mb != NULL && *mb) { free((*mb)->data);
free((*mb)->data); free(*mb);
free(*mb); *mb = NULL;
*mb = NULL; }
}
return TGBOT_REQUEST_ERROR;
return TGBOT_REQUEST_ERROR; }
}
curl_easy_cleanup(curl);
curl_easy_cleanup(curl);
return TGBOT_OK;
return TGBOT_OK; }
}
tgbot_rc tgbot_get_me(tgbot_s *bot, tgbot_me_s *me) {
tgbot_rc tgbot_get_me(tgbot *bot, tgbot_me *me) { char url[1024];
char url[1024]; snprintf(url, sizeof(url), "%sgetMe", bot->api);
snprintf(url, sizeof(url), "%sgetMe", bot->api);
struct memory_buffer *mb;
struct memory_buffer *mb; tgbot_rc ret = tgbot_request(url, &mb, NULL);
tgbot_rc ret = tgbot_request(url, &mb, NULL); if (ret != TGBOT_OK) {
if (ret != TGBOT_OK) { free(mb->data);
free(mb->data); free(mb);
free(mb);
return TGBOT_GETME_ERROR;
return TGBOT_GETME_ERROR; }
}
json_object *json = json_tokener_parse(mb->data);
json_object *json = json_tokener_parse(mb->data); free(mb->data);
free(mb->data); free(mb);
free(mb);
json_object *ok = json_object_object_get(json, "ok");
json_object *ok = json_object_object_get(json, "ok"); if (!json_object_get_boolean(ok)) {
if (!json_object_get_boolean(ok)) { json_object_put(json);
json_object_put(json);
return TGBOT_GETME_ERROR;
return TGBOT_GETME_ERROR; }
}
json_object *result = json_object_object_get(json, "result");
json_object *result = json_object_object_get(json, "result"); json_object *first_name = json_object_object_get(result, "first_name");
json_object *first_name = json_object_object_get(result, "first_name"); strncpy(me->first_name, json_object_get_string(first_name), sizeof(me->first_name) - 1);
strncpy(me->first_name, json_object_get_string(first_name), sizeof(me->first_name) - 1); json_object *username = json_object_object_get(result, "username");
json_object *username = json_object_object_get(result, "username"); strncpy(me->username, json_object_get_string(username), sizeof(me->username) - 1);
strncpy(me->username, json_object_get_string(username), sizeof(me->username) - 1);
json_object_put(json);
json_object_put(json);
return TGBOT_OK;
return TGBOT_OK; }
}
tgbot_rc tgbot_send_message(tgbot_s *bot, int64_t chat_id, const char *text, const char *parse_mode, tgbot_inlinekeyboard_s *keyboard) {
tgbot_rc tgbot_send_message(tgbot *bot, int64_t chat_id, const char *text, const char *parse_mode, tgbot_inlinekeyboard *keyboard) { char url[1024];
char url[1024];
tgbot_json_option options[4] = {
tgbot_json_option options[4] = { {"chat_id", &chat_id, tgbot_opt_int64},
{"chat_id", &chat_id, tgbot_opt_int64}, {"text", (void *)text, tgbot_opt_string},
{"text", (void *)text, tgbot_opt_string}, {"parse_mode", (void *)parse_mode, tgbot_opt_string},
{"parse_mode", (void *)parse_mode, tgbot_opt_string}, {"reply_markup", keyboard, tgbot_opt_inlinekeyboard},
{"reply_markup", keyboard, tgbot_opt_inlinekeyboard}, };
}; json_object *rjson = json_builder(options, 4);
json_object *rjson = tgbot_json_builder(options, 4);
snprintf(url, sizeof(url), "%ssendMessage", bot->api);
snprintf(url, sizeof(url), "%ssendMessage", bot->api);
tgbot_rc ret = tgbot_request(url, NULL, rjson);
tgbot_rc ret = tgbot_request(url, NULL, rjson); json_object_put(rjson);
json_object_put(rjson);
if (ret != TGBOT_OK) {
if (ret != TGBOT_OK) { return TGBOT_SENDMESSAGE_ERROR;
return TGBOT_SENDMESSAGE_ERROR; }
}
return TGBOT_OK;
return TGBOT_OK; }
}
tgbot_rc tgbot_edit_message_text(tgbot_s *bot, int64_t chat_id, long message_id, const char *text, tgbot_inlinekeyboard_s *keyboard) {
tgbot_rc tgbot_edit_message_text(tgbot *bot, int64_t chat_id, long message_id, const char *text, tgbot_inlinekeyboard *keyboard) { char url[1024];
char url[1024];
tgbot_json_option options[4] = {
tgbot_json_option options[4] = { {"chat_id", &chat_id, tgbot_opt_int64},
{"chat_id", &chat_id, tgbot_opt_int64}, {"message_id", &message_id, tgbot_opt_int},
{"message_id", &message_id, tgbot_opt_int}, {"text", (void *)text, tgbot_opt_string},
{"text", (void *)text, tgbot_opt_string}, {"reply_markup", keyboard, tgbot_opt_inlinekeyboard},
{"reply_markup", keyboard, tgbot_opt_inlinekeyboard}, };
}; json_object *rjson = json_builder(options, 4);
json_object *rjson = tgbot_json_builder(options, 4);
snprintf(url, sizeof(url), "%seditMessageText", bot->api);
snprintf(url, sizeof(url), "%seditMessageText", bot->api);
tgbot_rc ret = tgbot_request(url, NULL, rjson);
tgbot_rc ret = tgbot_request(url, NULL, rjson); json_object_put(rjson);
json_object_put(rjson);
if (ret != TGBOT_OK) {
if (ret != TGBOT_OK) { return TGBOT_EDITMESSAGETEXT_ERROR;
return TGBOT_EDITMESSAGETEXT_ERROR; }
}
return TGBOT_OK;
return TGBOT_OK; }
}
tgbot_rc tgbot_send_dice(tgbot_s *bot, int64_t chat_id, const char *emoji) {
tgbot_rc tgbot_send_dice(tgbot *bot, int64_t chat_id, const char *emoji) { char url[1024];
char url[1024];
tgbot_json_option options[2] = {
tgbot_json_option options[2] = { {"chat_id", &chat_id, tgbot_opt_int64},
{"chat_id", &chat_id, tgbot_opt_int64}, {"emoji", (void *)emoji, tgbot_opt_string},
{"emoji", (void *)emoji, tgbot_opt_string}, };
}; json_object *rjson = json_builder(options, 2);
json_object *rjson = tgbot_json_builder(options, 2);
snprintf(url, sizeof(url), "%ssendDice", bot->api);
snprintf(url, sizeof(url), "%ssendDice", bot->api);
tgbot_rc ret = tgbot_request(url, NULL, rjson);
tgbot_rc ret = tgbot_request(url, NULL, rjson); json_object_put(rjson);
json_object_put(rjson);
if (ret != TGBOT_OK) {
if (ret != TGBOT_OK) { return TGBOT_SENDDICE_ERROR;
return TGBOT_SENDDICE_ERROR; }
}
return TGBOT_OK;
return TGBOT_OK; }
}

46
src/tgbot.c
View File

@@ -1,20 +1,26 @@
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include "tgbot.h" #include "tgbot.h"
tgbot_rc tgbot_init(tgbot *bot, char *token) { tgbot_s *tgbot_new(char *token) {
curl_global_init(CURL_GLOBAL_DEFAULT); tgbot_s *bot = malloc(sizeof(tgbot_s));
if (!bot) {
snprintf(bot->api, sizeof(bot->api), "https://api.telegram.org/bot%s/", token); return NULL;
snprintf(bot->token, sizeof(bot->token), "%s", token); }
bot->offset = 0;
curl_global_init(CURL_GLOBAL_DEFAULT);
return TGBOT_OK;
} snprintf(bot->api, sizeof(bot->api), "https://api.telegram.org/bot%s/", token);
snprintf(bot->token, sizeof(bot->token), "%s", token);
void tgbot_destroy(tgbot *bot) { bot->offset = 0;
curl_global_cleanup();
} return bot;
}
void tgbot_free(tgbot_s *bot) {
curl_global_cleanup();
free(bot);
}

82
src/types.c
View File

@@ -1,41 +1,41 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "types.h" #include "types.h"
tgbot_inlinekeyboard *tgbot_new_inlinekeyboard(size_t rows, size_t columns) { tgbot_inlinekeyboard_s *tgbot_inlinekb_new(size_t rows, size_t columns) {
tgbot_inlinekeyboard *keyboard = (tgbot_inlinekeyboard *)malloc(sizeof(tgbot_inlinekeyboard)); tgbot_inlinekeyboard_s *keyboard = (tgbot_inlinekeyboard_s *)malloc(sizeof(tgbot_inlinekeyboard_s));
if (!keyboard) if (!keyboard)
return NULL; return NULL;
keyboard->rows = rows; keyboard->rows = rows;
keyboard->columns = columns; keyboard->columns = columns;
keyboard->buttons = (tgbot_inlinekeyboardbutton *)malloc(rows * columns * sizeof(tgbot_inlinekeyboardbutton)); keyboard->buttons = (tgbot_inlinekeyboardbutton_s *)malloc(rows * columns * sizeof(tgbot_inlinekeyboardbutton_s));
if (!keyboard->buttons) { if (!keyboard->buttons) {
free(keyboard); free(keyboard);
return NULL; return NULL;
} }
memset(keyboard->buttons, 0, rows * columns * sizeof(tgbot_inlinekeyboardbutton)); memset(keyboard->buttons, 0, rows * columns * sizeof(tgbot_inlinekeyboardbutton_s));
return keyboard; return keyboard;
} }
void tgbot_destroy_inlinekeyboard(tgbot_inlinekeyboard *keyboard) { void tgbot_inlinekb_free(tgbot_inlinekeyboard_s *keyboard) {
free(keyboard->buttons); free(keyboard->buttons);
free(keyboard); free(keyboard);
} }
tgbot_rc tgbot_inlinekeyboard_button(tgbot_inlinekeyboard *keyboard, size_t row, size_t column, const char *text, const char *url, const char *callback_data) { tgbot_inlinekeyboardbutton_s *tgbot_inlinekb_button_at(tgbot_inlinekeyboard_s *keyboard, size_t row, size_t column) {
tgbot_inlinekeyboardbutton *button = tgbot_inlinekeyboard_button_at(keyboard, row, column); return &keyboard->buttons[row * keyboard->columns + column];
}
strncpy(button->text, text, sizeof(button->text) - 1);
strncpy(button->url, url, sizeof(button->url) - 1); tgbot_rc tgbot_inlinekb_button(tgbot_inlinekeyboard_s *keyboard, size_t row, size_t column, const char *text, const char *url, const char *callback_data) {
strncpy(button->callback_data, callback_data, sizeof(button->callback_data) - 1); tgbot_inlinekeyboardbutton_s *button = tgbot_inlinekb_button_at(keyboard, row, column);
return TGBOT_OK; strncpy(button->text, text, sizeof(button->text) - 1);
} strncpy(button->url, url, sizeof(button->url) - 1);
strncpy(button->callback_data, callback_data, sizeof(button->callback_data) - 1);
tgbot_inlinekeyboardbutton *tgbot_inlinekeyboard_button_at(tgbot_inlinekeyboard *keyboard, size_t row, size_t column) {
return &keyboard->buttons[row * keyboard->columns + column]; return TGBOT_OK;
} }