¿Usas telegram? programa tu bot en C

[AlbertoBSD]

Buen dia compañeros.

Quiero compartirles el proyecto en el que estoy trabajando.

Una interfaz en C para que programen su bot para telegram.

El codigo esta disponible en github, aun lo sigo mejorando y optimizando lo mas que pueda.
Casi todo el programa es memoria dimanica la cual  administra muy bien la aplicacion.

Ejemplo de uso.

Código (c) [Seleccionar] Expandir


/*
* Luis Alberto
* Twitter @albertobsd
*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<curl/curl.h>
#include<sys/stat.h>
#include<errno.h>
#include"telegram.h"
#include"jsmn.h"

int main() {
Updates *updates;
User *user;
Message *message;
File *file;
char **variables;
char **valores;
int i = 0;
char *filename;
telegram_init("123456789:zwxecrvtbynuyvbnmutyguhjdkeosdgjhfdouhn");
user = telegram_getMe();
if(!telegram_is_error()) {
printf("User: id: %i\nusername: %s\n",user->id,user->username);
telegram_free_user(user);
}
else {
printf("%s\n",telegram_get_error());
}
updates = telegram_getUpdates();
if(!telegram_is_error()){
printf("updates: %i\n",updates->length);
while(i < updates->length) {
if(updates->list[i]->item.message->document) {
printf("Document exits file_id : %s\n",updates->list[i]->item.message->document->file_id);
file = telegram_getFile(updates->list[i]->item.message->document->file_id);
if(!telegram_is_error()) {
filename = telegram_downloadFile(file,updates->list[i]->item.message->document->file_name);
printf("file name : %s\n",filename);
}
else {
printf("%s\n",telegram_get_error());
}
}
i++;
}
telegram_free_updates(updates);
}
else {
printf("%s\n",telegram_get_error());
}
variables = calloc(5,sizeof(char*));
valores = calloc(5,sizeof(char*));
variables[0] = "chat_id";
variables[1] = "text";
valores[0] = "9219883";
valores[1] ="Texto de prueba";
message = telegram_sendMessage(telegram_build_post(variables,valores));
if(!telegram_is_error()) {
printf("OK %s\n",message->text);
telegram_free_message(message);
}
else {
printf("%s\n",telegram_get_error());
}
variables[1] = "caption";
valores[1] = "Envio archivo";
message = telegram_sendDocument("test_telegram",variables,valores);
if(!telegram_is_error()) {
printf("OK %s\n",message->text);
telegram_free_message(message);
}
else {
printf("%s\n",telegram_get_error());
}
return 0;
}




Para trabajar con este ejemplo tenemos que te generar un token de autorización para nuestro bot y editar la linea de codigo:

Código (c) [Seleccionar] Expandir

telegram_init("123456789:zwxecrvtbynuyvbnmutyguhjdkeosdgjhfdouhn");

en este ejemplo procesamos las peticiciones:

getMe
getUpdates
sendDocument

Tambien que tenemos que sustituir el chat_id por el nuestro
El codigo depende de que tengamos instalado libcurl

Codigo en gihub

https://github.com/albertobsd/libtelegrambot

Saludos!

[Stakewinner00]

Interesante. Un día estaba pensando en hacer un bot en C++ que al final no hice, así que me resultara útil tu aporte por si algún día retomo la idea.

Por cierto, porque usas calloc en vez de malloc?

[AlbertoBSD]

Como indica la documentacion de stdlib.

malloc y calloc reservan memoria. sin embargo no hay  garantia que la memoria reservada por malloc este limpia. A veces si a veces no.

calloc por otra parte es como malloc + memset(ptr,0,length). reserva memoria y la limpia. es importante tener la memoria limpia por que a veces haces condicidiones como:

Código [Seleccionar] Expandir

if(ptr!=NULL)
{
free(ptr);
}

basta que exista un byte de basura en la memoria para que la condicion se cumpla y el programa se cuelgue por tratar de liberar memoria inexistente o en su defecto escribir en un area no reservada.

https://www.freebsd.org/cgi/man.cgi?query=calloc&sektion=3&apropos=0&manpath=redhat

calloc()    allocates memory for an array of nmemb   elements of size bytes
      each and   returns   a pointer to the allocated memory.  The   memory is  set
      to zero.

      malloc()    allocates  size  bytes   and returns a pointer to the allocated
      memory.   The memory is not cleared.

[Eternal Idol]

Es todo correcto excepto lo de la condicion, la memoria asignada al puntero no la podes comparar de esa manera, de esa manera estas comparando la direccion a la que apunta el puntero con NULL y sera NULL con malloc o calloc en caso de fallo al reservar.

[Stakewinner00]

De la documentación también, si hay un error malloc retorna NULL igual que calloc (se me avanzaron..), no le sacas partido a calloc ya que no veo para que te sirve que inicialize a 0 cuando luego lo sobrescribieras.

[AlbertoBSD]

no le sacas partido a calloc ya que no veo para que te sirve que inicialize a 0 cuando luego lo sobrescribieras.

No seas vago. Es importante que el area en la que vas a escribir no tenga basura Me a pasado muchas veces que reservo exactamente la memoria que voy a usar + un byte. y algunas veces tu esperas que ese byte sea 0 y te quedas con esa idea y luego el programa empieza a hacer cosas raras y despues de pasara un rato depurando con GDB te das cuenta que la memoria tenia basura. cambias la instruccion a calloc o le agregas un memset despues del malloc y ahora todo funciona al 100.

Es todo correcto excepto lo de la condicion, la memoria asignada al puntero no la podes comparar de esa manera, de esa manera estas comparando la direccion a la que apunta el puntero con NULL y sera NULL con malloc o calloc en caso de fallo al reservar.

entiendo el punto, el codigo mostrado va cuando yo voy a liberar la memoria despues de usarla, si es que se usado,

Por ejemplo las funciones que ofresco para liberar la memoria

Código (c) [Seleccionar] Expandir


void telegram_free_updates(Updates *updates) {
int i = 0;
if(updates) {
while(i < updates->length) {
if(updates->list[i])
telegram_free_update(updates->list[i]);
i++;
}
memset(updates,0,sizeof(Updates));
free(updates);
}
}


[Eternal Idol]

El ejemplo correcto seria una estructura que tiene punteros por ejemplo, ahi el no inicializar la estructura correctamente puede tener graves consecuencias.

Por ejemplo las funciones que ofresco para liberar la memoria

Código (c) [Seleccionar] Expandir


void telegram_free_updates(Updates *updates) {
int i = 0;
if(updates) {
while(i < updates->length) {
if(updates->list[i])
telegram_free_update(updates->list[i]);
i++;
}
memset(updates,0,sizeof(Updates));
free(updates);
}
}


No tiene mucho sentido el memset ahi, poner la memoria a cero para inmediatamente liberarla es una perdida de tiempo, salvo que sean datos que querramos asegurarnos de que no queden en memoria por temas de seguridad. Ese memset no va a evitar que la variable con la cual llamaste a telegram_free_updates (en la cual no podes escribir ya que no la pasaste como doble puntero o referencia, updates es una variable local pasada por valor) continue apuntando al mismo bloque de memoria que liberas con free.

Código (c) [Seleccionar] Expandir

Updates *u = (Updates*)malloc(sizeof(Updates));
telegram_free_updates(u);
//u continua apuntando a la direccion de memoria que le haya retornado malloc

[AlbertoBSD]

Ese memset no va a evitar que la variable con la cual llamaste a telegram_free_updates (en la cual no podes escribir ya que no la pasaste como doble puntero o referencia, updates es una variable local pasada por valor) continue apuntando al mismo bloque de memoria que liberas con free.

Código (c) [Seleccionar] Expandir

Updates *u = (Updates*)malloc(sizeof(Updates));
telegram_free_updates(u);
//u continua apuntando a la direccion de memoria que le haya retornado malloc

Tienes razon es lo que me quede pensando cuando respondi hace rato voy a cambiat el tipo de funcion y retornar NULL.
Y quedaria asi:

Código (c) [Seleccionar] Expandir


u= telegram_free_updates(u).

Gracias por el aporte

[MAFUS]

Código (c) [Seleccionar] Expandir

u = telegram_free_updates(u)
Ese código es extraño y se ve forzado y tienes muy en cuenta la buena voluntad del cliente de tu función, cuándo debería ser al revés y pensar en el peor de los casos.
Si esa persona hace lo siguiente

Código (c) [Seleccionar] Expandir

telegram_free_updates(u)
u seguirá apuntando a algún sitio.
Debería ser la función mismo la que llevara u a NULL.
Tendría que estar definida tal que así

Código (c) [Seleccionar] Expandir


void telegram_free_updates(Updates **updates) {
   Updates *u = *updates;
   if(u) {
       int i;
       for(i = 0; i < u->length; ++i)
           if(u->list[i])
               telegram_free_updates(&u->list[i]);
   }
   *updates = NULL;
}
Con esto la variable obtendrá el valor NULL.

Una cosa más. Para que esto tenga sentido entiendo que has definido Updates de la siguiente forma

Código (c) [Seleccionar] Expandir


typedef struct updates_t {
   /*
    * Aquí van definidos
    * campos para el uso
    * del programa
    */
   unsigned length;
   struct updates_t **list;
} Updates;
De nuevo el código me parece extraño pues el mismo tipo de datos contiene un array dinámico de sí mismo. De esta manera uno puede meter Updates dentro de Updates dentro de Updates... con lo que se pierde rápidamente el control de lo que ocurre.
Podrías implementar un tipo de dato contenedor de Updates, para que te sirviera de array dinámico, y el tipo Updates por otra parte. Con un struct anónimo tal que así

Código (c) [Seleccionar] Expandir


typedef struct update_t {
   /*
    * Aquí van definidos
    * campos para el uso
    * del programa
    */
} Update;

struct {
   unsigned length;
   Update **list;
} Updates;


Así te aseguras que solo hay un único array de Update en todo el programa.

[Eternal Idol]

Tienes razon es lo que me quede pensando cuando respondi hace rato voy a cambiat el tipo de funcion y retornar NULL.
Y quedaria asi:

Código (c) [Seleccionar] Expandir


u= telegram_free_updates(u).

Gracias por el aporte

De nada pero todo eso es problema del caller y ademas de no asignar el valor de retorno podria tener mas variables apuntando al mismo bloque de memoria