refactor: improve code using cppcheck

.clang-format

@@ -1,8 +1,8 @@
+BasedOnStyle: LLVM
 UseTab: Always
-IndentWidth: 4
 TabWidth: 4
-ColumnLimit: 0
+IndentWidth: 4
-AllowAllParametersOfDeclarationOnNextLine: false
+IndentCaseLabels: true
-BreakBeforeBinaryOperators: None
+ColumnLimit: 120
-SpacesInParentheses: false
+PointerAlignment: Right
-BinPackParameters: true
+AllowShortFunctionsOnASingleLine: None

.clangd

@@ -1 +1,2 @@
-HeaderInsertion: Never
+Completion:
+    HeaderInsertion: Never

.gitignore

@@ -1,56 +1,56 @@
-.build/
+build/
-.cache/
+.cache/
-.token
+.token
-
+
-# Prerequisites
+# Prerequisites
-*.d
+*.d
-
+
-# Object files
+# Object files
-*.o
+*.o
-*.ko
+*.ko
-*.obj
+*.obj
-*.elf
+*.elf
-
+
-# Linker output
+# Linker output
-*.ilk
+*.ilk
-*.map
+*.map
-*.exp
+*.exp
-
+
-# Precompiled Headers
+# Precompiled Headers
-*.gch
+*.gch
-*.pch
+*.pch
-
+
-# Libraries
+# Libraries
-*.lib
+*.lib
-*.a
+*.a
-*.la
+*.la
-*.lo
+*.lo
-
+
-# Shared objects (inc. Windows DLLs)
+# Shared objects (inc. Windows DLLs)
-*.dll
+*.dll
-*.so
+*.so
-*.so.*
+*.so.*
-*.dylib
+*.dylib
-
+
-# Executables
+# Executables
-*.exe
+*.exe
-*.out
+*.out
-*.app
+*.app
-*.i*86
+*.i*86
-*.x86_64
+*.x86_64
-*.hex
+*.hex
-
+
-# Debug files
+# Debug files
-*.dSYM/
+*.dSYM/
-*.su
+*.su
-*.idb
+*.idb
-*.pdb
+*.pdb
-
+
-# Kernel Module Compile Results
+# Kernel Module Compile Results
-*.mod*
+*.mod*
-*.cmd
+*.cmd
-.tmp_versions/
+.tmp_versions/
-modules.order
+modules.order
-Module.symvers
+Module.symvers
-Mkfile.old
+Mkfile.old
-dkms.conf
+dkms.conf

.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-    "clangd.arguments": [
-        "--header-insertion=never",
-    ]
-}

README.md

@@ -1,58 +1,63 @@
-# tgbot
+# tgbot
-A minimal C Telegram API Framework
+
-
+A minimal C Telegram API Framework.
-## Requirements
+
-- meson
+## Requirements
-- libcurl
+
-- json-c
+- libcurl
-
+- json-c
-> Note: This project is purely educational. It does not aim to cover the entire Telegram Bot API, but only a selected subset of methods.
+
-
+> Note: This project is purely educational. It does not aim to cover the entire Telegram Bot API, but only a selected subset of methods.
-## How to build
+
-
+## How to build
-<details>
+
-
+<details>
-<summary>Linux</summary>
+
-
+<summary>Linux</summary>
-```bash
+
-$ meson setup build
+```bash
-$ cd build
+$ meson setup build
-$ meson compile
+$ cd build
-$ meson install
+$ meson compile
-```
+$ meson install
-
+```
-</details>
+
-
+</details>
-<details>
+
-
+<details>
-<summary>Windows</summary>
+
-
+<summary>Windows</summary>
-Install all the required library with `vcpkg` and then copy the DLL file.
+
-
+Install all the required library with `vcpkg` and then copy the DLL file.
-```powershell
+
-$ meson setup build --native-file meson-vcpkg.txt
+```powershell
-$ cd build
+$ meson setup build --native-file meson-vcpkg.txt
-$ meson compile
+$ cd build
-$ meson install
+$ meson compile
-```
+$ meson install
-
+```
-</details>
+
-
+</details>
-## Examples
+
-You can find some examples [here](./examples/).
+## Examples
-
+
-### Supported Types
+You can find some examples [here](./examples/).
-- **InlineKeyboardMarkup**
+
-  - Note: Standard `KeyboardMarkup` is intentionally not supported.
+### Supported Types
-
+
-#### Supported Methods
+- **InlineKeyboardMarkup**
-- `getMe`
+  - Note: Standard `KeyboardMarkup` is intentionally not supported.
-- `sendMessage`
+
-- `editMessageText`
+#### Supported Methods
-- `sendDice`
+
-
+- `getMe`
-## Roadmap
+- `sendMessage`
-- `sendPhoto`
+- `editMessageText`
-- `sendAudio`
+- `sendDice`
-- `sendDocument`
+
-- `sendVideo`
+## Roadmap
+
+- `sendPhoto`
+- `sendAudio`
+- `sendDocument`
+- `sendVideo`

examples/echobot/echobot.c

@@ -1,52 +1,52 @@
-#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;
+	(void)signum;
-}
+	run = false;
-
+}
-void echo_message(tgbot *bot, tgbot_update *update) {
+
-	tgbot_send_message(bot, update->chat_id, update->text, "MARKDOWN", NULL);
+void echo_message(tgbot_s *bot, tgbot_update_s *update) {
-}
+	tgbot_send_message(bot, update->chat_id, update->text, "MARKDOWN", NULL);
-
+}
-int main(void) {
+
-	/* Retrieve bot's token */
+int main(void) {
-	FILE *fp = fopen(".token", "r");
+	/* Retrieve bot's token */
-	if (fp == NULL) {
+	FILE *fp = fopen(".token", "r");
-		fprintf(stderr, "Unable to retrieve bot token\n");
+	if (fp == NULL) {
-		return 1;
+		fprintf(stderr, "Unable to retrieve bot token\n");
-	}
+		return 1;
-
+	}
-	char token[256];
+
-	fscanf(fp, "%s", token);
+	char token[256];
-	fprintf(stdout, "Token: %s\n", token);
+	fscanf(fp, "%s", token);
-	fclose(fp);
+	fprintf(stdout, "Token: %s\n", token);
-
+	fclose(fp);
-	signal(SIGINT, sighandler);
+
-
+	signal(SIGINT, sighandler);
-	/* Initialize bot */
+
-	tgbot bot;
+	/* Initialize bot */
-	tgbot_init(&bot, token);
+	tgbot_s *bot = tgbot_new(token);
-	tgbot_update update;
+	tgbot_update_s 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_destroy(&bot);
+	tgbot_free(bot);
-
+
-	return 0;
+	return 0;
-}
+}

examples/inlinekeyboard/inlinekeyboard.c

@@ -1,119 +1,118 @@
-#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(const tgbot_s *bot, const tgbot_update_s *update);
-void sighandler(int signum);
+void sighandler(int signum);
-void callback_parser(tgbot *bot, tgbot_cbquery *query);
+
-
+bool run = true;
-bool run = true;
+tgbot_s *bot;
-tgbot bot;
+tgbot_inlinekeyboard_s *keyboard;
-tgbot_inlinekeyboard *keyboard;
+
-
+/* Callback handler function */
-/* Callback handler function */
+void callback_handler(tgbot_s *bot, tgbot_cbquery_s *query) {
-void callback_handler(tgbot *bot, tgbot_cbquery *query) {
+	if (strcmp("test-callback", query->data) == 0) {
-	if (strcmp("test-callback", query->data) == 0) {
+		/* Handle `test-callback` */
-		/* Handle `test-callback` */
+		tgbot_inlinekeyboard_s *home_keyboard = tgbot_inlinekb_new(1, 1);
-		tgbot_inlinekeyboard *home_keyboard = tgbot_new_inlinekeyboard(1, 1);
+		/* Add buttons */
-		/* Add buttons */
+		tgbot_inlinekb_button(home_keyboard, 0, 0, "Home", "", "home");
-		tgbot_inlinekeyboard_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_inlinekb_free(home_keyboard);
-		tgbot_destroy_inlinekeyboard(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) {
+	(void)signum;
-	fprintf(stdout, "Closing...\n");
+	fprintf(stdout, "Closing...\n");
-	run = false;
+	run = false;
-}
+}
-
+
-void parse_command(tgbot *bot, tgbot_update *update) {
+void parse_command(const tgbot_s *bot, const 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;
+	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, "%255s", 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 */
+	bot = tgbot_new(token);
-	ret = tgbot_init(&bot, token);
+	if (!bot) {
-	if (ret != TGBOT_OK) {
+		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_s update;
-	tgbot_update update;
+	/* Allocate the new inline keyboard (remember to free!) */
-	/* Allocate the new inline keyboard (remember to free!) */
+	keyboard = tgbot_inlinekb_new(1, 2);
-	keyboard = tgbot_new_inlinekeyboard(1, 2);
+	if (keyboard == NULL) {
-	if (keyboard == NULL) {
+		tgbot_free(bot);
-		tgbot_destroy(&bot);
+		return 1;
-		return 1;
+	}
-	}
+
-
+	/* Populate the InlineKeyboardMarkup */
-	/* Populate the InlineKeyboardMarkup */
+	tgbot_inlinekb_button(keyboard, 0, 0, "Google", "https://google.com", "");
-	tgbot_inlinekeyboard_button(keyboard, 0, 0, "Google", "https://google.com", "");
+	tgbot_inlinekb_button(keyboard, 0, 1, "Callback", "", "test-callback");
-	tgbot_inlinekeyboard_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) {
+		tgbot_rc 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_inlinekb_free(keyboard);
-	tgbot_destroy_inlinekeyboard(keyboard);
+	tgbot_free(bot);
-	tgbot_destroy(&bot);
+
-
+	return 0;
-	return 0;
+}
-}

include/common.h

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

include/json.h

@@ -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_option_s *options, size_t optionslen);
-json_object *tgbot_new_inlinekeyboardmarkup(tgbot_inlinekeyboard *keyboard);
+
-
+json_object *json_ikb_new(tgbot_inlinekeyboard_s *keyboard);
-#endif
+
+#endif

include/methods.h

@@ -1,23 +1,20 @@
-#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);
+/* Retrieve update */
-tgbot_rc tgbot_parse_message(tgbot *bot, tgbot_update *update, json_object *result);
+tgbot_rc tgbot_get_update(tgbot_s *bot, tgbot_update_s *update, Callback cbq_handler);
-tgbot_rc tgbot_parse_cbquery(tgbot *bot, tgbot_cbquery *query, json_object *result, Callback query_handler);
+
-
+/* Methods */
-/* Request */
+tgbot_rc tgbot_get_me(const tgbot_s *bot, tgbot_me_s *me);
-size_t write_callback(void *ptr, size_t size, size_t nmemb, char **userdata);
+tgbot_rc tgbot_send_message(const tgbot_s *bot, int64_t chat_id, const char *text, const char *parse_mode,
-tgbot_rc tgbot_request(const char *url, struct memory_buffer **mb, json_object *json);
+							tgbot_inlinekeyboard_s *reply_markup);
-
+tgbot_rc tgbot_send_dice(const tgbot_s *bot, int64_t chat_id, const char *emoji);
-/* Methods */
+
-tgbot_rc tgbot_get_me(tgbot *bot, tgbot_me *me);
+/* Updating Methods */
-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_edit_message_text(const tgbot_s *bot, int64_t chat_id, long message_id, const char *text,
-tgbot_rc tgbot_send_dice(tgbot *bot, int64_t chat_id, const char *emoji);
+								 tgbot_inlinekeyboard_s *keyboard);
-
+
-/* Updating Methods */
+#endif
-tgbot_rc tgbot_edit_message_text(tgbot *bot, int64_t chat_id, long message_id, const char *text, tgbot_inlinekeyboard *keyboard);
-
-#endif

include/parse.h

@@ -0,0 +1,11 @@
+#ifndef TGBOT_PARSE_H
+#define TGBOT_PARSE_H
+
+#include "common.h"
+#include <json-c/json.h>
+
+tgbot_rc tgbot_parse_message(tgbot_s *bot, tgbot_update_s *update, json_object *result);
+
+tgbot_rc tgbot_parse_cbquery(tgbot_s *bot, tgbot_cbquery_s *query, json_object *result, Callback cbq_handler);
+
+#endif

include/tgbot.h

@@ -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(const 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

include/types.h

@@ -1,68 +1,71 @@
-#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,
- * @brief Returns a pointer to the keyboard's button.
+							   const char *url, const char *callback_data);
- *
+
- * @param[in] keyboard Keyboard.
+/**
- * @param[in] row Row index of the button.
+ * @brief Returns a pointer to the keyboard's button.
- * @param[in] column Column index of the button.
+ *
- *
+ * @param[in] keyboard Keyboard.
- * @return Pointer to the button, or NULL if the position is invalid.
+ * @param[in] row Row index of the button.
- */
+ * @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.
-/**
+ */
- * @brief Frees all memory associated with the given inline keyboard.
+tgbot_inlinekeyboardbutton_s *tgbot_inlinekb_button_at(tgbot_inlinekeyboard_s *keyboard, size_t row, size_t column);
- *
+
- * @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

meson-vcpkg.txt

@@ -1,28 +1,28 @@
-[constants]
+[constants]
-vcpkg_base_path = 'C:/vcpkg/'
+vcpkg_base_path = 'C:/vcpkg/'
-vcpkg_base_install_dir = 'C:/vcpkg/installed/'
+vcpkg_base_install_dir = 'C:/vcpkg/installed/'
-
+
-vcpkg_target_triplet = 'x64-windows'
+vcpkg_target_triplet = 'x64-windows'
-vcpkg_host_triplet = 'x64-windows'
+vcpkg_host_triplet = 'x64-windows'
-
+
-vcpkg_installed_dir =  vcpkg_base_install_dir + vcpkg_target_triplet + '/'
+vcpkg_installed_dir =  vcpkg_base_install_dir + vcpkg_target_triplet + '/'
-vcpkg_host_installed_dir = vcpkg_base_install_dir + vcpkg_host_triplet + '/'
+vcpkg_host_installed_dir = vcpkg_base_install_dir + vcpkg_host_triplet + '/'
-vcpkg_toolchain_file =  vcpkg_base_path + 'scripts/toolchains/windows.cmake'
+vcpkg_toolchain_file =  vcpkg_base_path + 'scripts/toolchains/windows.cmake'
-
+
-[properties]
+[properties]
-cmake_toolchain_file = vcpkg_base_path + 'scripts/buildsystems/vcpkg.cmake'
+cmake_toolchain_file = vcpkg_base_path + 'scripts/buildsystems/vcpkg.cmake'
-
+
-[binaries]
+[binaries]
-vcpkg = [ vcpkg_base_path + 'vcpkg.exe']
+vcpkg = [ vcpkg_base_path + 'vcpkg.exe']
-pkgconfig = [ vcpkg_installed_dir + 'tools/pkgconf/pkgconf.exe']
+pkgconfig = [ vcpkg_installed_dir + 'tools/pkgconf/pkgconf.exe']
-
+
-[cmake]
+[cmake]
-VCPKG_TARGET_TRIPLET = vcpkg_target_triplet
+VCPKG_TARGET_TRIPLET = vcpkg_target_triplet
-VCPKG_HOST_TRIPLET = vcpkg_host_triplet
+VCPKG_HOST_TRIPLET = vcpkg_host_triplet
-VCPKG_CHAINLOAD_TOOLCHAIN_FILE = vcpkg_base_path + 'scripts/toolchains/windows.cmake'
+VCPKG_CHAINLOAD_TOOLCHAIN_FILE = vcpkg_base_path + 'scripts/toolchains/windows.cmake'
-_VCPKG_INSTALLED_DIR = vcpkg_installed_dir
+_VCPKG_INSTALLED_DIR = vcpkg_installed_dir
-VCPKG_CRT_LINKAGE = 'dynamic'
+VCPKG_CRT_LINKAGE = 'dynamic'
-
+
-[built-in options]
+[built-in options]
-pkg_config_path =  [ vcpkg_installed_dir + 'lib/pkgconfig;' + vcpkg_installed_dir + 'share/pkgconfig']
+pkg_config_path =  [ vcpkg_installed_dir + 'lib/pkgconfig;' + vcpkg_installed_dir + 'share/pkgconfig']
 cmake_prefix_path = [ vcpkg_installed_dir ]

meson.build

@@ -1,30 +1,39 @@
-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,
+tgbot_dep = declare_dependency(
-    include_directories: inc_dir,
+  link_with: tgbot_lib,
-)
+  include_directories: inc_dir,
+  dependencies: deps,
+)
+
+# Example
+executable(
+  'example',
+  'examples/inlinekeyboard/inlinekeyboard.c',
+  dependencies: tgbot_dep,
+)

src/json.c

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

src/meson.build

@@ -1,6 +1,7 @@
-sources += files(
+sources += files(
-    'json.c',
+  'json.c',
-    'methods.c',
+  'methods.c',
-    'tgbot.c',
+  'parse.c',
-    'types.c',
+  'tgbot.c',
-)
+  'types.c',
+)

src/methods.c

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

src/parse.c

@@ -0,0 +1,100 @@
+#include "parse.h"
+
+tgbot_rc tgbot_parse_message(tgbot_s *bot, tgbot_update_s *update, json_object *result) {
+	json_object *update_id = json_object_object_get(result, "update_id");
+	bot->offset = json_object_get_int(update_id) + 1;
+	update->update_id = json_object_get_int(update_id);
+
+	json_object *message = json_object_object_get(result, "message");
+	json_object *message_id = json_object_object_get(message, "message_id");
+	if (message_id) {
+		update->message_id = json_object_get_int(message_id);
+	}
+
+	json_object *chat = json_object_object_get(message, "chat");
+	json_object *chat_id = json_object_object_get(chat, "id");
+	if (chat_id) {
+		update->chat_id = json_object_get_int64(chat_id);
+	}
+
+	json_object *chat_first_name = json_object_object_get(chat, "first_name");
+	if (chat_first_name) {
+		snprintf(update->chat_first_name, sizeof(update->chat_first_name), "%s",
+				 json_object_get_string(chat_first_name));
+	}
+
+	json_object *chat_last_name = json_object_object_get(chat, "last_name");
+	if (chat_last_name) {
+		snprintf(update->chat_last_name, sizeof(update->chat_last_name), "%s", json_object_get_string(chat_last_name));
+	}
+
+	json_object *chat_username = json_object_object_get(chat, "username");
+	if (chat_username != NULL) {
+		snprintf(update->chat_username, sizeof(update->chat_username), "%s", json_object_get_string(chat_username));
+	}
+
+	json_object *chat_type = json_object_object_get(chat, "type");
+	if (chat_type) {
+		snprintf(update->chat_type, sizeof(update->chat_type), "%s", json_object_get_string(chat_type));
+	}
+
+	json_object *date = json_object_object_get(message, "date");
+	if (date) {
+		update->date = json_object_get_int(date);
+	}
+
+	json_object *text = json_object_object_get(message, "text");
+	if (text) {
+		snprintf(update->text, sizeof(update->text), "%s", json_object_get_string(text));
+	}
+
+	return TGBOT_OK;
+}
+
+tgbot_rc tgbot_parse_cbquery(tgbot_s *bot, tgbot_cbquery_s *query, json_object *result, Callback cbq_handler) {
+	json_object *update_id = json_object_object_get(result, "update_id");
+	bot->offset = json_object_get_int(update_id) + 1;
+	query->update_id = json_object_get_int(update_id);
+
+	json_object *callback_query = json_object_object_get(result, "callback_query");
+	json_object *message = json_object_object_get(callback_query, "message");
+	json_object *message_id = json_object_object_get(message, "message_id");
+	if (message_id) {
+		query->message_id = json_object_get_int(message_id);
+	}
+
+	json_object *chat = json_object_object_get(message, "chat");
+	json_object *chat_id = json_object_object_get(chat, "id");
+	if (chat_id) {
+		query->chat_id = json_object_get_int64(chat_id);
+	}
+
+	json_object *chat_username = json_object_object_get(chat, "username");
+	if (chat_username) {
+		snprintf(query->chat_username, sizeof(query->chat_username), "%s", json_object_get_string(chat_username));
+	}
+
+	json_object *date = json_object_object_get(message, "date");
+	if (date) {
+		query->date = json_object_get_int(date);
+	}
+
+	json_object *text = json_object_object_get(message, "text");
+	if (text) {
+		snprintf(query->text, sizeof(query->text), "%s", json_object_get_string(text));
+	}
+
+	json_object *chat_instance = json_object_object_get(callback_query, "chat_instance");
+	if (chat_instance) {
+		snprintf(query->chat_instance, sizeof(query->chat_instance), "%s", json_object_get_string(chat_instance));
+	}
+
+	json_object *data = json_object_object_get(callback_query, "data");
+	if (data) {
+		snprintf(query->data, sizeof(query->data), "%s", json_object_get_string(data));
+	}
+
+	cbq_handler(bot, query);
+
+	return TGBOT_OK;
+}

src/tgbot.c

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

src/types.c

@@ -1,41 +1,44 @@
-#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->columns = columns;
+
-	keyboard->buttons = (tgbot_inlinekeyboardbutton *)malloc(rows * columns * sizeof(tgbot_inlinekeyboardbutton));
+	keyboard->rows = rows;
-	if (!keyboard->buttons) {
+	keyboard->columns = columns;
-		free(keyboard);
+	keyboard->buttons = (tgbot_inlinekeyboardbutton_s *)malloc(rows * columns * sizeof(tgbot_inlinekeyboardbutton_s));
-
+	if (!keyboard->buttons) {
-		return NULL;
+		free(keyboard);
-	}
+
-
+		return NULL;
-	memset(keyboard->buttons, 0, rows * columns * sizeof(tgbot_inlinekeyboardbutton));
+	}
-
+
-	return keyboard;
+	memset(keyboard->buttons, 0, rows * columns * sizeof(tgbot_inlinekeyboardbutton_s));
-}
+
-
+	return keyboard;
-void tgbot_destroy_inlinekeyboard(tgbot_inlinekeyboard *keyboard) {
+}
-	free(keyboard->buttons);
+
-	free(keyboard);
+void tgbot_inlinekb_free(tgbot_inlinekeyboard_s *keyboard) {
-}
+	free(keyboard->buttons);
-
+	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 *button = tgbot_inlinekeyboard_button_at(keyboard, row, column);
+
-
+tgbot_inlinekeyboardbutton_s *tgbot_inlinekb_button_at(tgbot_inlinekeyboard_s *keyboard, size_t row, size_t column) {
-	strncpy(button->text, text, sizeof(button->text) - 1);
+	return &keyboard->buttons[row * keyboard->columns + column];
-	strncpy(button->url, url, sizeof(button->url) - 1);
+}
-	strncpy(button->callback_data, callback_data, sizeof(button->callback_data) - 1);
+
-
+tgbot_rc tgbot_inlinekb_button(tgbot_inlinekeyboard_s *keyboard, size_t row, size_t column, const char *text,
-	return TGBOT_OK;
+							   const char *url, const char *callback_data) {
-}
+	tgbot_inlinekeyboardbutton_s *button = tgbot_inlinekb_button_at(keyboard, row, column);
-
+
-tgbot_inlinekeyboardbutton *tgbot_inlinekeyboard_button_at(tgbot_inlinekeyboard *keyboard, size_t row, size_t column) {
+	strncpy(button->text, text, sizeof(button->text) - 1);
-	return &keyboard->buttons[row * keyboard->columns + column];
+	strncpy(button->url, url, sizeof(button->url) - 1);
-}
+	strncpy(button->callback_data, callback_data, sizeof(button->callback_data) - 1);
+
+	return TGBOT_OK;
+}