systemd-gotify/main.c

#include<stdio.h>
#include<stdlib.h>
#include<curl/curl.h>
#include<string.h>
#include<dbus/dbus.h>

int gotify_message(char *,char *,char *);
int systemdCall(DBusConnection *,char *, char *);
int checkIsActive(DBusConnection *connection, char *service_name);
int systemdUnitCall(DBusConnection *connection,char *target,char *method,char *param,char **result);
/*
 *sytemctl show gotify-server | grep PID
 * */

int main(void)
{
	unsigned long uid;
	int ret,i;

    char **objects = NULL;
	dbus_bool_t allow_user=0;
	DBusConnection *connection=NULL;
	DBusError error;
    char *result;
	
	dbus_error_init(&error);
	connection = dbus_bus_get(DBUS_BUS_SESSION,&error);//DBUS_BUS_SYSTEM
	if(dbus_error_is_set(&error))
	{
		fprintf(stderr,"%s",error.message);
		return -1;
	}	
	printf("This is my unique dbus name: %s\n",dbus_bus_get_unique_name(connection));

    ret = dbus_bus_request_name(connection,"test.method.client",DBUS_NAME_FLAG_REPLACE_EXISTING,&error);
	if(dbus_error_is_set(&error))
	{
		fprintf(stderr,"%s",error.message);
		return -1;
    }
    else
    {
        printf("name requested from dbus: %d\n",ret);
    }    

	dbus_connection_set_allow_anonymous(connection,allow_user);
	printf("user auth dbus requ: %d\n",allow_user);
	if(!dbus_connection_list_registered(connection,"/",&objects))
    {
            for(i=0;objects[i];i++)
            {
                    printf("\nobject dbus: %s",objects[i]);
            }
    }
    else{
            printf("dbus_connection_list_registered error\n");
    }

	if((ret=dbus_connection_get_unix_user(connection,&uid))==1)
	{
		printf("found USERID:%ld",uid);
	}
	else
	{
		printf("NO userID set in dbus session: %d\n",ret);
	}

    //org/freedesktop/systemd1
    //systemdCall(connection,"GetUnit","timers.target");
    //systemdCall(connection,"ListUnits",NULL);

    systemdUnitCall(connection,"/org/freedesktop/systemd1/unit/timers_2etarget","Get","SubState",&result);
    systemdUnitCall(connection,"/org/freedesktop/systemd1/unit/sysinit_2etarget","Get","SubState",&result);
    printf("result systemdUnitCall: %s\n",result);
	gotify_message("https://5ccppi.org:4433/message?token=ApPFbwayM5zDXf3","anothertitle","anothermessage");

	return 0;
}

int gotify_message(char *url,char *title,char *message)
{
	int ret;
	CURL *curl;
	CURLcode res;
	char post_buffer[128];

	curl = curl_easy_init();

	ret = snprintf(post_buffer,sizeof(post_buffer),"title=%s&message=%s",title,message);
	if(ret < sizeof(post_buffer))
	{
		printf("%s %d",post_buffer,ret);

		if(curl)
		{
			curl_easy_setopt(curl,CURLOPT_URL,url);
			curl_easy_setopt(curl,CURLOPT_POSTFIELDS,post_buffer);
			curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION,1L);

			res = curl_easy_perform(curl);
			if(res != CURLE_OK)
			{
				fprintf(stderr,"curl_easy_perform failed: %s",curl_easy_strerror(res));
			}
			curl_easy_cleanup(curl);
		}
	}
	else{
		printf("Error on string concelblalbla: %d",ret);
	}

	return 0;
}

int systemdCall(DBusConnection *connection,char *method,char *param)
{
        
	DBusError error;
    DBusMessage *msg;
    DBusMessage *ret_msg;
    DBusMessageIter iter;
    DBusMessageIter array_iter;

    char *reply_msg=NULL;
    int ret1,ret2;

	dbus_error_init(&error);

    msg = dbus_message_new_method_call("org.freedesktop.systemd1","/org/freedesktop/systemd1","org.freedesktop.systemd1.Manager",method);
    if(NULL == msg)
    {
            fprintf(stderr,"Message null, no message created");
            return 1;
    }
    else
    {
            printf("message created!\n");
    }
    

    if(param != NULL)
    {
            dbus_message_iter_init_append(msg,&iter);
            if(!dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&param))
            {
                    fprintf(stderr,"Error appending");
                    return -1;
            }
            else{
                    printf("message appended\n");
            }
    }

    ret_msg = dbus_connection_send_with_reply_and_block(connection,msg,DBUS_TIMEOUT_INFINITE,&error);
    if(ret_msg == NULL)
    {
            fprintf(stderr,"error on receiving message from peer\n");
    }
    else
    {
            DBusMessageIter reply_iter;
            dbus_message_iter_init(ret_msg,&reply_iter);
            ret1=dbus_message_iter_get_arg_type(&reply_iter);

            while(ret1 != DBUS_TYPE_INVALID)
            {
                    if(ret1 == *DBUS_TYPE_OBJECT_PATH_AS_STRING)
                    {
                            printf("succesfull received message\narg type %c\n",ret1);
                            dbus_message_iter_get_basic(&reply_iter,&reply_msg);
                            printf("returned value: %s\n",reply_msg);
                    }
                    if(ret1 == DBUS_TYPE_STRING)
                    {
                            printf("succesfull received message\narg type %c\n",ret1);
                            dbus_message_iter_get_basic(&reply_iter,&reply_msg);
                            printf("Received message:%s\n",reply_msg);
                    }
                    if(ret1 == DBUS_TYPE_ARRAY)
                    {
                            int element_count = dbus_message_iter_get_element_count(&reply_iter);
                            printf("Array:Elem count %d\n",element_count);
                            //ret2 = dbus_message_iter_get_element_type(&reply_iter);
                            dbus_message_iter_recurse(&reply_iter,&array_iter);
                            int i2=0;
                            ret2 = dbus_message_iter_get_arg_type(&array_iter);
                            while(ret2 != DBUS_TYPE_INVALID)
                            {

                                    //printf("type:%c\n",ret2);

                                            //dbus_message_iter_get_basic(&array_iter,&reply_msg);
                                    //printf("Received message:%s\n",reply_msg);
                                    ret2 = dbus_message_iter_get_arg_type(&array_iter);
                                    
                                    DBusMessageIter sub_iter;
                                    int ret3;
                                    dbus_message_iter_recurse(&array_iter,&sub_iter);
                                    ret3 = dbus_message_iter_get_arg_type(&sub_iter);
                                    while(ret3 != DBUS_TYPE_INVALID)
                                    {
                                            ret3 = dbus_message_iter_get_arg_type(&sub_iter);
                                            //printf("arr_sub_iter:%c\n",ret3);
                                            if(ret3 == DBUS_TYPE_STRING)
                                            {
                                                    dbus_message_iter_get_basic(&sub_iter,&reply_msg);
                                                    printf("%s\n",reply_msg);
                                            }
                                            ret3=dbus_message_iter_next(&sub_iter);
                                    }


                                   ret2=dbus_message_iter_next(&array_iter);
                                   i2++;
                                   //printf("i2:%d\n",i2);
                             }
                    }
                //printf("iter:%c\n",ret1);
                    ret1=dbus_message_iter_next(&reply_iter);

            }

    }
	if(dbus_error_is_set(&error))
	{
		fprintf(stderr,"%s\n",error.message);
		return -1;
	}	
    return 0;
}

int systemdUnitCall(DBusConnection *connection,char *target,char *method,char *param,char **result)
{
        
	DBusError error;
    DBusMessage *msg;
    DBusMessage *ret_msg;
    DBusMessageIter iter;
    DBusMessageIter array_iter;
    DBusMessageIter variant_iter;
    
    result=NULL;
    char *reply_msg=NULL;
    int ret1,ret2;
    char *param2 = "org.freedesktop.systemd1.Unit";

	dbus_error_init(&error);
                                        //dest(servcice/bus)   ,path(object)  ,iface  method
    msg = dbus_message_new_method_call("org.freedesktop.systemd1",target,"org.freedesktop.DBus.Properties",method);
    if(NULL == msg)
    {
            fprintf(stderr,"Message null, no message created\n");
            return 1;
    }
    else
    {
            printf("message created!\n");
    }
    

    if(param2 != NULL)
    {
            dbus_message_iter_init_append(msg,&iter);
            if(!dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&param2))
            {
                    fprintf(stderr,"Error appending");
                    return -1;
            }
            else{
                    printf("message appended\n");
            }
            if(!dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&param))
            {
                    fprintf(stderr,"Error appending");
                    return -1;
            }
            else{
                    printf("message appended\n");
            }
    }

    ret_msg = dbus_connection_send_with_reply_and_block(connection,msg,DBUS_TIMEOUT_INFINITE,&error);
    if(ret_msg == NULL)
    {
            fprintf(stderr,"error ond receiving message from peer\n");
    }
    else
    {
            DBusMessageIter reply_iter;
            dbus_message_iter_init(ret_msg,&reply_iter);
            ret1=dbus_message_iter_get_arg_type(&reply_iter);
            printf("ret1 type:%c\n",ret1);
            while(ret1 != DBUS_TYPE_INVALID)
            {
                    if(ret1 == DBUS_TYPE_OBJECT_PATH)
                    {
                            printf("succesfull received message\narg type %c\n",ret1);
                            dbus_message_iter_get_basic(&reply_iter,&reply_msg);
                            printf("returned value: %s\n",reply_msg);
                    }
                    if(ret1 == DBUS_TYPE_STRING)
                    {
                            printf("succesfull received message\narg type %c\n",ret1);
                            dbus_message_iter_get_basic(&reply_iter,&reply_msg);
                            printf("Received message:%s\n",reply_msg);
                    }
                    if(ret1 == DBUS_TYPE_VARIANT)
                    {
                            dbus_message_iter_recurse(&reply_iter,&variant_iter);
                            char *type = dbus_message_iter_get_signature(&variant_iter);
                            printf("str_val:%s\n",type);
                            if(type[0] == DBUS_TYPE_STRING)
                            {
                                   // result = malloc(sizeof(char)*64);
                                    dbus_message_iter_get_basic(&variant_iter,*result);
                                   // printf("result inside function:%s\n",*result);
                            }
                            //dbus_message_iter_get_basic(&reply_iter,&value);

                    }
                    if(ret1 == DBUS_TYPE_ARRAY)
                    {
                            int element_count = dbus_message_iter_get_element_count(&reply_iter);
                            printf("Array:Elem count %d\n",element_count);
                            //ret2 = dbus_message_iter_get_element_type(&reply_iter);
                            dbus_message_iter_recurse(&reply_iter,&array_iter);
                            int i2=0;
                            ret2 = dbus_message_iter_get_arg_type(&array_iter);
                            while(ret2 != DBUS_TYPE_INVALID)
                            {
                                    ret2 = dbus_message_iter_get_arg_type(&array_iter);
                                    DBusMessageIter sub_iter;
                                    int ret3;
                                    dbus_message_iter_recurse(&array_iter,&sub_iter);
                                    ret3 = dbus_message_iter_get_arg_type(&sub_iter);
                                    while(ret3 != DBUS_TYPE_INVALID)
                                    {
                                            ret3 = dbus_message_iter_get_arg_type(&sub_iter);
                                            //printf("arr_sub_iter:%c\n",ret3);
                                            if(ret3 == DBUS_TYPE_STRING)
                                            {
                                                    dbus_message_iter_get_basic(&sub_iter,&reply_msg);
                                                    printf("%s\n",reply_msg);
                                            }
                                            ret3=dbus_message_iter_next(&sub_iter);
                                    }


                                   ret2=dbus_message_iter_next(&array_iter);
                                   i2++;
                                   //printf("i2:%d\n",i2);
                             }
                    }
                //printf("iter:%c\n",ret1);
                    ret1=dbus_message_iter_next(&reply_iter);

            }

    }
	if(dbus_error_is_set(&error))
	{
		fprintf(stderr,"%s\n",error.message);
		return -1;
	}	
    return 0;
}
/*
int checkIsActive(DBusConnection *connection, char *service_name)
{
    systemdCall(connection,    
}*/