450 lines
12 KiB
C
450 lines
12 KiB
C
/* $Id$ */
|
|
/* Copyright (c) 2011-2025 Pierre Pronchery <khorben@defora.org> */
|
|
/* This file is part of DeforaOS System libApp */
|
|
/* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, version 3 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <System.h>
|
|
#include "App/appserver.h"
|
|
#include "App/apptransport.h"
|
|
|
|
#ifndef PROGNAME_APPBROKER
|
|
# define PROGNAME_APPBROKER "AppBroker"
|
|
#endif
|
|
|
|
|
|
/* AppBroker */
|
|
/* private */
|
|
/* types */
|
|
typedef struct _AppBrokerPrefs
|
|
{
|
|
AppTransportMode mode;
|
|
char const * outfile;
|
|
int dryrun;
|
|
} AppBrokerPrefs;
|
|
|
|
typedef struct _AppBroker
|
|
{
|
|
AppBrokerPrefs prefs;
|
|
Config * config;
|
|
char const * prefix;
|
|
FILE * fp;
|
|
int error;
|
|
} AppBroker;
|
|
|
|
|
|
/* prototypes */
|
|
static int _appbroker(AppBrokerPrefs * prefs, char const * filename);
|
|
static int _usage(void);
|
|
|
|
|
|
/* functions */
|
|
static void _appbroker_calls(AppBroker * appbroker);
|
|
static void _appbroker_callbacks(AppBroker * appbroker);
|
|
static void _appbroker_constants(AppBroker * appbroker);
|
|
static char const * _appbroker_ctype(char const * type);
|
|
static int _appbroker_do(AppBroker * appbroker, AppTransportMode mode);
|
|
static int _appbroker_foreach_call(char const * key, Hash * value, void * data);
|
|
static int _appbroker_foreach_call_arg(AppBroker * appbroker, char const * sep,
|
|
char const * arg);
|
|
static int _appbroker_foreach_callback(char const * key, Hash * value,
|
|
void * data);
|
|
static int _appbroker_foreach_constant(char const * key, char const * value,
|
|
void * data);
|
|
static void _appbroker_head(AppBroker * appbroker);
|
|
static void _appbroker_tail(AppBroker * appbroker);
|
|
|
|
static int _appbroker(AppBrokerPrefs * prefs, char const * filename)
|
|
{
|
|
AppBroker appbroker;
|
|
|
|
if(prefs != NULL)
|
|
appbroker.prefs = *prefs;
|
|
else
|
|
{
|
|
memset(&appbroker.prefs, 0, sizeof(appbroker.prefs));
|
|
appbroker.prefs.mode = ATM_SERVER;
|
|
}
|
|
if((appbroker.config = config_new()) == NULL)
|
|
return error_print(PROGNAME_APPBROKER);
|
|
if(config_load(appbroker.config, filename) != 0
|
|
|| (appbroker.prefix = config_get(appbroker.config,
|
|
NULL, "service")) == NULL)
|
|
{
|
|
config_delete(appbroker.config);
|
|
return error_print(PROGNAME_APPBROKER);
|
|
}
|
|
appbroker.fp = NULL;
|
|
if(_appbroker_do(&appbroker, appbroker.prefs.mode) == 0
|
|
&& appbroker.prefs.dryrun == 0)
|
|
{
|
|
if(appbroker.prefs.outfile == NULL)
|
|
appbroker.fp = stdout;
|
|
else if((appbroker.fp = fopen(appbroker.prefs.outfile, "w"))
|
|
== NULL)
|
|
{
|
|
config_delete(appbroker.config);
|
|
return error_set_print(PROGNAME_APPBROKER, 1, "%s: %s",
|
|
appbroker.prefs.outfile,
|
|
strerror(errno));
|
|
}
|
|
_appbroker_do(&appbroker, appbroker.prefs.mode);
|
|
}
|
|
if(appbroker.fp != NULL && appbroker.prefs.outfile != NULL)
|
|
fclose(appbroker.fp);
|
|
config_delete(appbroker.config);
|
|
return appbroker.error;
|
|
}
|
|
|
|
static void _appbroker_calls(AppBroker * appbroker)
|
|
{
|
|
if(appbroker->fp != NULL)
|
|
fputs("\n/* calls */\n", appbroker->fp);
|
|
hash_foreach(appbroker->config,
|
|
(HashForeach)_appbroker_foreach_call, appbroker);
|
|
}
|
|
|
|
static void _appbroker_callbacks(AppBroker * appbroker)
|
|
{
|
|
if(appbroker->fp != NULL)
|
|
fputs("\n\n/* callbacks */\n", appbroker->fp);
|
|
hash_foreach(appbroker->config,
|
|
(HashForeach)_appbroker_foreach_callback, appbroker);
|
|
}
|
|
|
|
static void _appbroker_constants(AppBroker * appbroker)
|
|
{
|
|
Hash * hash;
|
|
|
|
if((hash = hash_get(appbroker->config, "constants")) == NULL)
|
|
return;
|
|
if(appbroker->fp != NULL)
|
|
fputs("\n\n/* constants */\n", appbroker->fp);
|
|
hash_foreach(hash, (HashForeach)_appbroker_foreach_constant, appbroker);
|
|
}
|
|
|
|
static char const * _appbroker_ctype(char const * type)
|
|
{
|
|
struct
|
|
{
|
|
char const * type;
|
|
char const * ctype;
|
|
} ctypes[] =
|
|
{
|
|
{ "VOID", "void", },
|
|
{ "BOOL", "bool", },
|
|
{ "INT8", "int8_t", },
|
|
{ "UINT8", "uint8_t", },
|
|
{ "INT16", "int16_t", },
|
|
{ "UINT16", "uint16_t", },
|
|
{ "INT32", "int32_t", },
|
|
{ "UINT32", "uint32_t", },
|
|
{ "INT64", "int64_t", },
|
|
{ "UINT64", "uint64_t", },
|
|
{ "FLOAT", "float", },
|
|
{ "DOUBLE", "double", },
|
|
{ "BUFFER", "Buffer const *", },
|
|
{ "STRING", "String const *", },
|
|
{ "BOOL_IN", "bool", },
|
|
{ "INT8_IN", "int8_t", },
|
|
{ "UINT8_IN", "uint8_t", },
|
|
{ "INT16_IN", "int16_t", },
|
|
{ "UINT16_IN", "uint16_t", },
|
|
{ "INT32_IN", "int32_t", },
|
|
{ "UINT32_IN", "uint32_t", },
|
|
{ "INT64_IN", "int64_t", },
|
|
{ "UINT64_IN", "uint64_t", },
|
|
{ "FLOAT_IN", "float", },
|
|
{ "DOUBLE_IN", "double", },
|
|
{ "BUFFER_IN", "Buffer const *", },
|
|
{ "STRING_IN", "String const *", },
|
|
{ "BOOL[]", "bool const *", },
|
|
{ "INT8[]", "int8_t const *", },
|
|
{ "UINT8[]", "uint8_t const *", },
|
|
{ "INT16[]", "int16_t const *", },
|
|
{ "UINT16[]", "uint16_t const *", },
|
|
{ "INT32[]", "int32_t const *", },
|
|
{ "UINT32[]", "uint32_t const *", },
|
|
{ "INT64[]", "int64_t const *", },
|
|
{ "UINT64[]", "uint64_t const *", },
|
|
{ "FLOAT[]", "float const *", },
|
|
{ "DOUBLE[]", "double const *", },
|
|
{ "BUFFER[]", "Buffer const **", },
|
|
{ "STRING[]", "String const **", },
|
|
{ "BOOL_IN[]", "bool const *", },
|
|
{ "INT8_IN[]", "int8_t const *", },
|
|
{ "UINT8_IN[]", "uint8_t const *", },
|
|
{ "INT16_IN[]", "int16_t const *", },
|
|
{ "UINT16_IN[]", "uint16_t const *", },
|
|
{ "INT32_IN[]", "int32_t const *", },
|
|
{ "UINT32_IN[]", "uint32_t const *", },
|
|
{ "INT64_IN[]", "int64_t const *", },
|
|
{ "UINT64_IN[]", "uint64_t const *", },
|
|
{ "FLOAT_IN[]", "float const *", },
|
|
{ "DOUBLE_IN[]", "double const *", },
|
|
{ "BUFFER_IN[]", "Buffer const **", },
|
|
{ "STRING_IN[]", "String const **", },
|
|
{ "BOOL_OUT", "bool *", },
|
|
{ "INT8_OUT", "int8_t *", },
|
|
{ "UINT8_OUT", "uint8_t *", },
|
|
{ "INT16_OUT", "int16_t *", },
|
|
{ "UINT16_OUT", "uint16_t *", },
|
|
{ "INT32_OUT", "int32_t *", },
|
|
{ "UINT32_OUT", "uint32_t *", },
|
|
{ "INT64_OUT", "int64_t *", },
|
|
{ "UINT64_OUT", "uint64_t *", },
|
|
{ "FLOAT_OUT", "float *", },
|
|
{ "DOUBLE_OUT", "double *", },
|
|
{ "BUFFER_OUT", "Buffer *", },
|
|
{ "STRING_OUT", "String **", },
|
|
{ "BOOL_INOUT", "bool *", },
|
|
{ "INT8_INOUT", "int8_t *", },
|
|
{ "UINT8_INOUT", "uint8_t *", },
|
|
{ "INT16_INOUT", "int16_t *", },
|
|
{ "UINT16_INOUT", "uint16_t *", },
|
|
{ "INT32_INOUT", "int32_t *", },
|
|
{ "UINT32_INOUT", "uint32_t *", },
|
|
{ "INT64_INOUT", "int64_t *", },
|
|
{ "UINT64_INOUT", "uint64_t *", },
|
|
{ "FLOAT_INOUT", "float *", },
|
|
{ "DOUBLE_INOUT", "double *", },
|
|
{ "BUFFER_INOUT", "Buffer *", },
|
|
{ "STRING_INOUT", "String **" },
|
|
{ "BOOL_OUT[]", "bool *", },
|
|
{ "INT8_OUT[]", "int8_t *", },
|
|
{ "UINT8_OUT[]", "uint8_t *", },
|
|
{ "INT16_OUT[]", "int16_t *", },
|
|
{ "UINT16_OUT[]", "uint16_t *", },
|
|
{ "INT32_OUT[]", "int32_t *", },
|
|
{ "UINT32_OUT[]", "uint32_t *", },
|
|
{ "INT64_OUT[]", "int64_t *", },
|
|
{ "UINT64_OUT[]", "uint64_t *", },
|
|
{ "FLOAT_OUT[]", "float *", },
|
|
{ "DOUBLE_OUT[]", "double *", },
|
|
{ "BUFFER_OUT[]", "Buffer *", },
|
|
{ "STRING_OUT[]", "String **", },
|
|
{ "BOOL_INOUT[]", "bool *", },
|
|
{ "INT8_INOUT[]", "int8_t *", },
|
|
{ "UINT8_INOUT[]", "uint8_t *", },
|
|
{ "INT16_INOUT[]", "int16_t *", },
|
|
{ "UINT16_INOUT[]", "uint16_t *", },
|
|
{ "INT32_INOUT[]", "int32_t *", },
|
|
{ "UINT32_INOUT[]", "uint32_t *", },
|
|
{ "INT64_INOUT[]", "int64_t *", },
|
|
{ "UINT64_INOUT[]", "uint64_t *", },
|
|
{ "FLOAT_INOUT[]", "float *", },
|
|
{ "DOUBLE_INOUT[]", "double *", },
|
|
{ "BUFFER_INOUT[]", "Buffer *", },
|
|
{ "STRING_INOUT[]", "String **", }
|
|
};
|
|
size_t i;
|
|
|
|
for(i = 0; i < sizeof(ctypes) / sizeof(*ctypes); i++)
|
|
if(strcmp(ctypes[i].type, type) == 0)
|
|
return ctypes[i].ctype;
|
|
return NULL;
|
|
}
|
|
|
|
static int _appbroker_do(AppBroker * appbroker, AppTransportMode mode)
|
|
{
|
|
appbroker->error = 0;
|
|
_appbroker_head(appbroker);
|
|
_appbroker_constants(appbroker);
|
|
(mode == ATM_SERVER) ? _appbroker_calls(appbroker)
|
|
: _appbroker_callbacks(appbroker);
|
|
_appbroker_tail(appbroker);
|
|
return appbroker->error;
|
|
}
|
|
|
|
static int _appbroker_foreach_call(char const * key, Hash * value, void * data)
|
|
{
|
|
AppBroker * appbroker = data;
|
|
const char prefix[] = "call::";
|
|
unsigned int i;
|
|
char buf[8];
|
|
char const * p;
|
|
const char sep[] = ", ";
|
|
|
|
if(key == NULL || key[0] == '\0')
|
|
return 0;
|
|
if(strncmp(key, prefix, sizeof(prefix) - 1) != 0)
|
|
return 0;
|
|
key += sizeof(prefix) - 1;
|
|
if((p = hash_get(value, "ret")) == NULL)
|
|
p = "VOID";
|
|
if((p = _appbroker_ctype(p)) == NULL)
|
|
appbroker->error = -error_set_print(PROGNAME_APPBROKER, 1,
|
|
"%s: %s", key, "Invalid return type for call");
|
|
if(appbroker->fp != NULL)
|
|
fprintf(appbroker->fp, "%s%s%s%s%s%s", p, " ",
|
|
appbroker->prefix, "_", key,
|
|
"(App * app, AppServerClient * client");
|
|
for(i = 0; i < APPSERVER_MAX_ARGUMENTS; i++)
|
|
{
|
|
snprintf(buf, sizeof(buf), "arg%u", i + 1);
|
|
if((p = hash_get(value, buf)) == NULL)
|
|
break;
|
|
if(_appbroker_foreach_call_arg(appbroker, sep, p) != 0)
|
|
return -1;
|
|
}
|
|
if(appbroker->fp != NULL)
|
|
fprintf(appbroker->fp, "%s", ");\n");
|
|
return 0;
|
|
}
|
|
|
|
static int _appbroker_foreach_call_arg(AppBroker * appbroker, char const * sep,
|
|
char const * arg)
|
|
{
|
|
char const * ctype;
|
|
char * p;
|
|
String * q;
|
|
|
|
if((p = strchr(arg, ',')) == NULL)
|
|
ctype = _appbroker_ctype(arg);
|
|
else if((q = string_new_length(arg, p - arg)) != NULL)
|
|
{
|
|
ctype = _appbroker_ctype(q);
|
|
string_delete(q);
|
|
}
|
|
else
|
|
{
|
|
appbroker->error = -1;
|
|
return -1;
|
|
}
|
|
if(appbroker->fp != NULL)
|
|
fprintf(appbroker->fp, "%s%s%s%s", sep, ctype,
|
|
(p != NULL && string_get_length(p + 1)) ? " " : "",
|
|
(p != NULL) ? p + 1 : "");
|
|
return 0;
|
|
}
|
|
|
|
static int _appbroker_foreach_callback(char const * key, Hash * value,
|
|
void * data)
|
|
{
|
|
/* XXX some code duplication with _appbroker_foreach_call() */
|
|
AppBroker * appbroker = data;
|
|
const char prefix[] = "callback::";
|
|
int i;
|
|
char buf[8];
|
|
char const * p;
|
|
const char sep[] = ", ";
|
|
|
|
if(key == NULL || key[0] == '\0')
|
|
return 0;
|
|
if(strncmp(key, prefix, sizeof(prefix) - 1) != 0)
|
|
return 0;
|
|
key += sizeof(prefix) - 1;
|
|
if((p = hash_get(value, "ret")) == NULL)
|
|
p = "VOID";
|
|
if((p = _appbroker_ctype(p)) == NULL)
|
|
appbroker->error = -error_set_print(PROGNAME_APPBROKER, 1,
|
|
"%s: %s", key, "Unknown return type for"
|
|
" callback");
|
|
if(appbroker->fp != NULL)
|
|
fprintf(appbroker->fp, "%s%s%s%s%s%s", p, " ",
|
|
appbroker->prefix, "_", key,
|
|
"(AppClient * client");
|
|
for(i = 0; i < APPSERVER_MAX_ARGUMENTS; i++)
|
|
{
|
|
snprintf(buf, sizeof(buf), "arg%u", i + 1);
|
|
if((p = hash_get(value, buf)) == NULL)
|
|
break;
|
|
if(_appbroker_foreach_call_arg(appbroker, sep, p) != 0)
|
|
return -1;
|
|
}
|
|
if(appbroker->fp != NULL)
|
|
fprintf(appbroker->fp, "%s", ");\n");
|
|
return 0;
|
|
}
|
|
|
|
static int _appbroker_foreach_constant(char const * key, char const * value,
|
|
void * data)
|
|
{
|
|
AppBroker * appbroker = data;
|
|
|
|
if(appbroker->fp != NULL)
|
|
fprintf(appbroker->fp, "# define %s_%s\t%s\n",
|
|
appbroker->prefix, key, value);
|
|
return 0;
|
|
}
|
|
|
|
static void _appbroker_head(AppBroker * appbroker)
|
|
{
|
|
if(appbroker->fp == NULL)
|
|
return;
|
|
fputs("/* $""Id$ */\n\n\n\n", appbroker->fp);
|
|
if(appbroker->prefix != NULL)
|
|
fprintf(appbroker->fp, "%s%s%s%s%s%s%s%s%s%s", "#ifndef ",
|
|
appbroker->prefix, "_",
|
|
appbroker->prefix, "_H\n", "# define ",
|
|
appbroker->prefix, "_",
|
|
appbroker->prefix, "_H\n");
|
|
fputs("\n# include <stdbool.h>\n", appbroker->fp);
|
|
fputs("# include <stdint.h>\n", appbroker->fp);
|
|
fputs("# include <System/App.h>\n\n", appbroker->fp);
|
|
}
|
|
|
|
static void _appbroker_tail(AppBroker * appbroker)
|
|
{
|
|
if(appbroker->prefix != NULL && appbroker->fp != NULL)
|
|
fprintf(appbroker->fp, "%s%s%s%s%s", "\n#endif /* !",
|
|
appbroker->prefix, "_",
|
|
appbroker->prefix, "_H */\n");
|
|
}
|
|
|
|
|
|
/* usage */
|
|
static int _usage(void)
|
|
{
|
|
fputs("Usage: " PROGNAME_APPBROKER " [-cns][-o outfile] filename\n"
|
|
" -n Only check for errors (dry-run)\n", stderr);
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* main */
|
|
int main(int argc, char * argv[])
|
|
{
|
|
int o;
|
|
AppBrokerPrefs prefs;
|
|
|
|
memset(&prefs, 0, sizeof(prefs));
|
|
prefs.mode = ATM_SERVER;
|
|
while((o = getopt(argc, argv, "cno:s")) != -1)
|
|
switch(o)
|
|
{
|
|
case 'c':
|
|
prefs.mode = ATM_CLIENT;
|
|
break;
|
|
case 'n':
|
|
prefs.dryrun = 1;
|
|
break;
|
|
case 'o':
|
|
prefs.outfile = optarg;
|
|
break;
|
|
case 's':
|
|
prefs.mode = ATM_SERVER;
|
|
break;
|
|
default:
|
|
return _usage();
|
|
}
|
|
if(optind + 1 != argc)
|
|
return _usage();
|
|
return (_appbroker(&prefs, argv[optind]) == 0) ? 0 : 2;
|
|
}
|