static int
bz_pacman__package__is_needed(void *user_data, bool *is_needed)
{
struct bz_env *env = user_data;
const char *package_name;
bool force = false;
rip_check(package_name = bz_env_get_string(env, "name", true));
rie_check(force = bz_env_get_bool(env, "force", true));
if (force) {
*is_needed = true;
clog_info("(%s) Force creation of binary package",
package_name);
return 0;
} else {
struct cork_path *package_file;
rip_check(package_file = bz_env_get_path
(env, "pacman.package_file", true));
clog_info("(%s) Check whether binary package %s exists",
package_name, cork_path_get(package_file));
rii_check(bz_file_exists(cork_path_get(package_file), is_needed));
*is_needed = !*is_needed;
return 0;
}
}
void tgdb_close_logfiles()
{
clog_info(CLOG_CGDB, "Closing logfile.");
clog_free(CLOG_CGDB_ID);
clog_info(CLOG_GDBIO, "Closing logfile.");
clog_free(CLOG_GDBIO_ID);
}
int main(int argc, char *argv[])
{
int level = CLOG_DEFAULT;
const char *lname = "DEFAULT";
clog_init(stdout, level, CLOG_DEFAULT_TS_FMT);
if(argc == 2) {
if(!strcmp("FATAL", argv[1])) { clog_set_level(level = CLOG_FATAL); lname = "FATAL"; }
if(!strcmp("ERROR", argv[1])) { clog_set_level(level = CLOG_ERROR); lname = "ERROR"; }
if(!strcmp("WARN", argv[1])) { clog_set_level(level = CLOG_WARN); lname = "WARN"; }
if(!strcmp("INFO", argv[1])) { clog_set_level(level = CLOG_INFO); lname = "INFO"; }
if(!strcmp("DEBUG", argv[1])) { clog_set_level(level = CLOG_DEBUG); lname = "DEBUG"; }
if(!strcmp("TRACE", argv[1])) { clog_set_level(level = CLOG_TRACE); lname = "TRACE"; }
}
fprintf(stdout, "--- %s ---\n", lname);
clog_fatal("this is %s log", "fatal");
clog_error("this is %s log", "error");
clog_warn("this is %s log", "warn");
clog_info("this is %s log", "info");
clog_debug("this is %s log", "debug");
clog_trace("this is %s log", "trace");
return 0;
}
static int
bz_autotools__stage(void *user_data)
{
struct bz_env *env = user_data;
const char *package_name;
struct cork_path *build_dir;
struct cork_path *staging_dir;
bool verbose;
struct cork_env *exec_env;
struct cork_exec *exec;
rii_check(bz_stage_message(env, "autotools"));
rip_check(package_name = bz_env_get_string(env, "name", true));
clog_info("(%s) Stage using autotools", package_name);
rip_check(build_dir = bz_env_get_path(env, "build_dir", true));
rip_check(staging_dir = bz_env_get_path(env, "staging_dir", true));
rie_check(verbose = bz_env_get_bool(env, "verbose", true));
/* Create the staging path */
rii_check(bz_create_directory(cork_path_get(staging_dir), 0750));
/* $ make install */
exec = cork_exec_new("make");
cork_exec_add_param(exec, "make");
cork_exec_add_param(exec, "install");
cork_exec_set_cwd(exec, cork_path_get(build_dir));
exec_env = cork_env_clone_current();
cork_env_add(exec_env, "DESTDIR", cork_path_get(staging_dir));
cork_exec_set_env(exec, exec_env);
return bz_subprocess_run_exec(verbose, NULL, exec);
}
int maltcp_del_endpoint(maltcp_poller_data_t *poller_data, mal_endpoint_t *endpoint) {
clog_info(maltcp_logger, " *** maltcp_del_endpoint: %s\n", mal_endpoint_get_uri(endpoint));
int found = -1;
for (int i=0; i<poller_data->idx; i++) {
if ((poller_data->endpoints[i] != NULL) &&
(poller_data->endpoints[i] == mal_endpoint_get_endpoint_data(endpoint))) {
found = i;
break;
}
}
if (found == -1) {
clog_warning(maltcp_logger, " *** maltcp_del_endpoint: Not found\n");
return -1;
}
poller_data->idx -= 1;
for (int i=found; i<poller_data->idx; i++) {
poller_data->endpoints[i] = poller_data->endpoints[i+1];
}
poller_data->endpoints[poller_data->idx] = NULL;
clog_debug(maltcp_logger, " *** maltcp_del_endpoint: OK\n");
return 0;
}
int tgdb_process(struct tgdb * tgdb)
{
const int n = 4096;
static char buf[n];
ssize_t size;
int result = 0;
// Cleanup those zombies!
tgdb_handle_sigchld(tgdb);
// If ^c has been typed at the prompt, clear the queues
tgdb_handle_control_c(tgdb);
size = io_read(tgdb->debugger_stdout, buf, n);
if (size < 0) {
// Error reading from GDB
clog_error(CLOG_CGDB, "Error reading from gdb's stdout, closing down");
result = -1;
tgdb_add_quit_command(tgdb);
} else if (size == 0) {
// Read EOF from GDB
clog_info(CLOG_GDBIO, "read EOF from GDB, closing down");
tgdb_add_quit_command(tgdb);
} else {
// Read some GDB console output, process it
result = annotations_parser_io(tgdb->parser, buf, size);
}
return result;
}
static int
bz_pacman__install__is_needed(void *user_data, bool *is_needed)
{
struct bz_env *env = user_data;
struct bz_value *ctx = bz_env_as_value(env);
const char *package_name;
struct bz_version *package_version;
bool force;
rii_check(bz_install_dependency_string("pacman", ctx));
rip_check(package_name = bz_env_get_string(env, "name", true));
rie_check(force = bz_env_get_bool(env, "force", true));
if (force) {
*is_needed = true;
clog_info("(%s) Force installation of package",
package_name);
return 0;
} else {
struct bz_version *installed;
clog_info("(%s) Check whether pacman package is installed",
package_name);
rip_check(package_version = bz_env_get_version(env, "version", true));
ee_check(installed = bz_arch_native_version_installed(package_name));
if (installed == NULL) {
clog_info("(%s) Package is not installed", package_name);
*is_needed = true;
return 0;
} else {
*is_needed = (bz_version_cmp(installed, package_version) < 0);
clog_info("(%s) Installed version %s is %s than %s",
package_name,
bz_version_to_string(installed),
*is_needed? "older": "newer",
bz_version_to_string(package_version));
bz_version_free(installed);
return 0;
}
}
error:
bz_version_free(package_version);
return -1;
}
maltcp_endpoint_data_t* maltcp_get_endpoint(maltcp_poller_data_t *poller_data, zsock_t *socket) {
clog_info(maltcp_logger, " *** mal_routing_get_endpoint: \n");
for (int i=0; i<poller_data->idx; i++) {
if (poller_data->endpoints[i]->socket == socket) {
clog_debug(maltcp_logger, " *** mal_routing_get_endpoint: OK\n");
return poller_data->endpoints[i];
}
}
return NULL;
}
int maltcp_add_endpoint(maltcp_poller_data_t *poller_data, mal_endpoint_t *endpoint) {
clog_info(maltcp_logger, " *** maltcp_add_endpoint: %s\n", mal_endpoint_get_uri(endpoint));
if (poller_data->idx < poller_data->max) {
// Includes the structure in the table
poller_data->endpoints[poller_data->idx++] =
(maltcp_endpoint_data_t *) mal_endpoint_get_endpoint_data(endpoint);
return 0;
} else {
clog_error(maltcp_logger, "Error :: Cannot add more than %d endpoints\n", poller_data->max);
return -1;
}
}
static int
bz_pacman__uninstall__is_needed(void *user_data, bool *is_needed)
{
struct bz_env *env = user_data;
struct bz_value *ctx = bz_env_as_value(env);
const char *package_name;
struct bz_version *installed;
rii_check(bz_install_dependency_string("pacman", ctx));
rip_check(package_name = bz_env_get_string(env, "name", true));
clog_info("(%s) Check whether pacman package is installed",
package_name);
rie_check(installed = bz_arch_native_version_installed(package_name));
if (installed == NULL) {
clog_info("(%s) Package is not installed", package_name);
*is_needed = false;
} else {
clog_info("(%s) Version %s is installed",
package_name, bz_version_to_string(installed));
*is_needed = true;
bz_version_free(installed);
}
return 0;
}
static int
bz_pacman__uninstall(void *user_data)
{
struct bz_env *env = user_data;
const char *package_name;
rii_check(bz_uninstall_message(env, "pacman"));
rip_check(package_name = bz_env_get_string(env, "name", true));
clog_info("(%s) Uninstall using pacman", package_name);
return bz_subprocess_run
(false, NULL,
"sudo", "pacman", "-R", "--noconfirm", package_name,
NULL);
}
static int
bz_pacman__install(void *user_data)
{
struct bz_env *env = user_data;
const char *package_name;
struct cork_path *package_file;
rii_check(bz_install_message(env, "pacman"));
rip_check(package_name = bz_env_get_string(env, "name", true));
rip_check(package_file = bz_env_get_path(env, "pacman.package_file", true));
clog_info("(%s) Install %s using pacman",
package_name, cork_path_get(package_file));
return bz_subprocess_run
(false, NULL,
"sudo", "pacman", "-U", "--noconfirm", cork_path_get(package_file),
NULL);
}
static int
bz_autotools__test(void *user_data)
{
struct bz_env *env = user_data;
const char *package_name;
struct cork_path *build_dir;
bool verbose;
struct cork_exec *exec;
rii_check(bz_test_message(env, "autotools"));
/* $ make check */
rip_check(package_name = bz_env_get_string(env, "name", true));
clog_info("(%s) Test using autotools", package_name);
rip_check(build_dir = bz_env_get_path(env, "build_dir", true));
rie_check(verbose = bz_env_get_bool(env, "verbose", true));
exec = cork_exec_new("make");
cork_exec_add_param(exec, "make");
cork_exec_add_param(exec, "check");
cork_exec_set_cwd(exec, cork_path_get(build_dir));
return bz_subprocess_run_exec(verbose, NULL, exec);
}
static int
bz_autotools__build(void *user_data)
{
struct bz_env *env = user_data;
struct bz_value *ctx = bz_env_as_value(env);
const char *package_name;
struct cork_path *build_dir;
struct cork_path *source_dir;
struct cork_path *configure;
struct bz_value *configure_args;
const char *pkgconfig_path;
bool exists;
bool verbose;
struct cork_exec *exec;
struct cork_env *exec_env;
struct cork_buffer buf = CORK_BUFFER_INIT();
rii_check(bz_install_dependency_string("autoconf", ctx));
rii_check(bz_install_dependency_string("automake", ctx));
rii_check(bz_build_message(env, "autotools"));
rip_check(package_name = bz_env_get_string(env, "name", true));
rip_check(build_dir = bz_env_get_path(env, "build_dir", true));
rip_check(source_dir = bz_env_get_path(env, "source_dir", true));
rip_check(configure =
bz_env_get_path(env, "autotools.configure.configure", true));
rie_check(pkgconfig_path = bz_env_get_string(env, "pkgconfig.path", false));
rie_check(verbose = bz_env_get_bool(env, "verbose", true));
/* Create the build path */
rii_check(bz_create_directory(cork_path_get(build_dir), 0750));
clog_info("(%s) Configure using autotools", package_name);
/* $ autoreconf -i */
rii_check(bz_file_exists(cork_path_get(configure), &exists));
if (!exists) {
exec = cork_exec_new("autoreconf");
cork_exec_add_param(exec, "autoreconf");
cork_exec_add_param(exec, "-i");
cork_exec_set_cwd(exec, cork_path_get(source_dir));
ei_check(bz_subprocess_run_exec(verbose, NULL, exec));
}
#define add_dir(buzzy_name, param_name) \
do { \
struct cork_path *value; \
ep_check(value = bz_env_get_path(env, buzzy_name, true)); \
cork_buffer_printf(&buf, "--" param_name "=%s", cork_path_get(value)); \
cork_exec_add_param(exec, buf.buf); \
} while (0)
/* $ ./configure ... */
exec = cork_exec_new(cork_path_get(configure));
exec_env = cork_env_clone_current();
cork_exec_set_env(exec, exec_env);
cork_exec_add_param(exec, cork_path_get(configure));
add_dir("prefix", "prefix");
add_dir("exec_prefix", "exec-prefix");
add_dir("bin_dir", "bindir");
add_dir("sbin_dir", "sbindir");
add_dir("lib_dir", "libdir");
add_dir("libexec_dir", "libexecdir");
add_dir("share_dir", "datadir");
add_dir("man_dir", "mandir");
/* Add custom configure arguments, if given. */
configure_args = bz_env_get_value(env, "autotools.configure.args");
if (configure_args != NULL) {
struct bz_configure_add_arg state = { exec, env };
switch (bz_value_kind(configure_args)) {
case BZ_VALUE_SCALAR:
ei_check(bz_configure_add_arg(&state, configure_args));
break;
case BZ_VALUE_ARRAY:
ei_check(bz_array_value_map
(configure_args, &state, bz_configure_add_arg));
break;
case BZ_VALUE_MAP:
bz_bad_config("autotools.configure.args cannot be a map");
goto error;
default:
cork_unreachable();
}
}
cork_exec_set_cwd(exec, cork_path_get(build_dir));
if (pkgconfig_path != NULL) {
cork_env_add(exec_env, "PKG_CONFIG_PATH", pkgconfig_path);
}
ei_check(bz_subprocess_run_exec(verbose, NULL, exec));
/* $ make */
clog_info("(%s) Build using autotools", package_name);
exec = cork_exec_new("make");
cork_exec_add_param(exec, "make");
cork_exec_set_cwd(exec, cork_path_get(build_dir));
ei_check(bz_subprocess_run_exec(verbose, NULL, exec));
cork_buffer_done(&buf);
return 0;
error:
cork_buffer_done(&buf);
return -1;
}
// Must be compliant with MAL virtual function: void *self
int maltcp_ctx_send_message(void *self, mal_endpoint_t *mal_endpoint, mal_message_t *mal_message) {
maltcp_ctx_t *maltcp_ctx = (maltcp_ctx_t *) self;
if (clog_is_loggable(maltcp_logger, CLOG_INFO_LEVEL)) {
clog_info(maltcp_logger, "maltcp_ctx_send_message:\n");
mal_message_print(mal_message);
clog_info(maltcp_logger, "\n");
}
int rc = 0;
mal_uri_t *uri_to = mal_message_get_uri_to(mal_message);
clog_debug(maltcp_logger, "maltcp_ctx_send_message: uri_to=%s\n", uri_to);
char *peer_uri = maltcp_get_base_uri(uri_to);
clog_debug(maltcp_logger, "maltcp_ctx_send_message: peer_uri=%s\n", peer_uri);
maltcp_ctx_connection_t *cnx_ptr = maltcp_ctx_socket_connect(maltcp_ctx, peer_uri);
if (cnx_ptr == NULL) {
clog_error(maltcp_logger, "maltcp_ctx_send_message: cannot create connection for %s.\n", peer_uri);
free(peer_uri);
return -1;
}
free(peer_uri);
// Note: We could use virtual allocation and initialization functions from encoder
// rather than malbinary interface.
malbinary_cursor_t cursor;
malbinary_cursor_reset(&cursor);
// TODO: In a first time we should separate the header and body size in order to send them
// in separate frames. In a second time we should cut the message in multiples frames.
// maltcp_add_message_encoding_length should not add body_length to encoding length
// bytes should content uniquely the header
// maltcp_encode_message should not copy the body to the bytes array
// we should creates and send 2 frames
// 'maltcp' encoding format of the MAL header
rc = maltcp_add_message_encoding_length(maltcp_ctx->maltcp_header, mal_message, maltcp_ctx->encoder, &cursor);
if (rc < 0)
return rc;
clog_debug(maltcp_logger, "maltcp_ctx: encoding_length=%d\n", malbinary_cursor_get_length(&cursor));
// Note: We could use virtual allocation and initialization functions from encoder
// rather than malbinary interface.
malbinary_cursor_init(&cursor,
(char *) malloc(malbinary_cursor_get_length(&cursor)),
malbinary_cursor_get_length(&cursor),
0);
clog_debug(maltcp_logger, "maltcp_ctx: mal_message_encode_malbinary\n");
// 'maltcp' encoding format of the MAL header
rc = maltcp_encode_message(maltcp_ctx->maltcp_header, mal_message, maltcp_ctx->encoder, &cursor);
if (rc < 0)
return rc;
assert(cursor.body_length == cursor.body_offset);
clog_debug(maltcp_logger, "maltcp_ctx: message is encoded: %d bytes\n", malbinary_cursor_get_offset(&cursor));
// send the message
if (maltcp_ctx_socket_send(cnx_ptr, &cursor) < 0)
return -1;
return 0;
}
static int
bz_pacman__package(void *user_data)
{
struct bz_env *env = user_data;
struct bz_value *ctx = bz_env_as_value(env);
struct cork_path *staging_dir;
struct cork_path *binary_package_dir;
struct cork_path *package_build_dir;
struct cork_path *pkgbuild;
struct cork_path *package_file;
const char *package_name;
const char *version;
const char *pkgrel;
const char *pkgext;
const char *architecture;
const char *license;
bool verbose;
struct cork_env *exec_env;
struct cork_exec *exec;
struct cork_buffer buf = CORK_BUFFER_INIT();
bool staging_exists;
rii_check(bz_install_dependency_string("pacman", ctx));
rii_check(bz_package_message(env, "pacman"));
rip_check(package_name = bz_env_get_string(env, "name", true));
clog_info("(%s) Package using pacman", package_name);
rip_check(staging_dir = bz_env_get_path(env, "staging_dir", true));
rip_check(binary_package_dir =
bz_env_get_path(env, "binary_package_dir", true));
rip_check(package_build_dir =
bz_env_get_path(env, "package_build_dir", true));
rip_check(pkgbuild = bz_env_get_path(env, "pacman.pkgbuild", true));
rip_check(package_file = bz_env_get_path(env, "pacman.package_file", true));
rip_check(version = bz_env_get_string(env, "pacman.version", true));
rip_check(pkgrel = bz_env_get_string(env, "pacman.pkgrel", true));
rip_check(pkgext = bz_env_get_string(env, "pacman.pkgext", true));
rip_check(architecture = bz_env_get_string(env, "pacman.arch", true));
rip_check(license = bz_env_get_string(env, "license", true));
rie_check(verbose = bz_env_get_bool(env, "verbose", true));
rii_check(bz_file_exists(cork_path_get(staging_dir), &staging_exists));
if (CORK_UNLIKELY(!staging_exists)) {
cork_error_set_printf
(ENOENT, "Staging directory %s does not exist",
cork_path_get(staging_dir));
return -1;
}
/* NOTE: pacman runs ldconfig automatically, so unlike the other packagers,
* we do NOT need to add an ldconfig call to the post-install and
* post-remove scripts. */
/* Create the temporary directory and the packaging destination */
rii_check(bz_create_directory(cork_path_get(package_build_dir), 0750));
rii_check(bz_create_directory(cork_path_get(binary_package_dir), 0750));
/* Create a PKGBUILD file for this package */
cork_buffer_append_printf(&buf, "pkgname='%s'\n", package_name);
cork_buffer_append_printf(&buf, "pkgver='%s'\n", version);
cork_buffer_append_printf(&buf, "pkgrel='%s'\n", pkgrel);
cork_buffer_append_printf(&buf, "arch=('%s')\n", architecture);
cork_buffer_append_printf(&buf, "license=('%s')\n", license);
rii_check(bz_pacman_fill_deps(env, &buf, "depends", "dependencies"));
cork_buffer_append_printf(&buf,
"package () {\n"
" rm -rf \"${pkgdir}\"\n"
" cp -a '%s' \"${pkgdir}\"\n"
"}\n",
cork_path_get(staging_dir)
);
/* Add pre- and post-install scripts, if necessary. */
rii_check(bz_pacman_add_install_scripts(env, &buf));
ei_check(bz_create_file(cork_path_get(pkgbuild), &buf, 0640));
cork_buffer_done(&buf);
exec_env = cork_env_clone_current();
cork_env_add(exec_env, "PKGDEST", cork_path_get(binary_package_dir));
cork_env_add(exec_env, "PKGEXT", pkgext);
exec = cork_exec_new_with_params("makepkg", "-sf", NULL);
cork_exec_set_cwd(exec, cork_path_get(package_build_dir));
cork_exec_set_env(exec, exec_env);
clog_info("(%s) Create %s using pacman",
package_name, cork_path_get(package_file));
return bz_subprocess_run_exec(verbose, NULL, exec);
error:
cork_buffer_done(&buf);
return -1;
}
