int setup_client(struct addrinfo *server_host)
{
int tSockDesc = -1;
int tIdx = 0;
while(tIdx++ < RETRY_COUNT)
{
tSockDesc = common_setup(server_host);
if (tSockDesc < 0 && tIdx >= RETRY_COUNT)
{
perror("Error: Could not create socket");
return ERROR;
}
if (connect(tSockDesc, server_host->ai_addr, server_host->ai_addrlen) >= 0)
{
return tSockDesc;
}
else
{
close(tSockDesc);
perror("Error: Could not connect to server");
struct timeval tRes;
delay(RETRY_DELAY, &tRes);
}
}
printf("%d Retry attempts exceeded\n", RETRY_COUNT);
return ERROR;
}
static gboolean
handle_delete (UDisksLogicalVolume *_volume,
GDBusMethodInvocation *invocation,
GVariant *options)
{
GError *error = NULL;
UDisksLinuxLogicalVolume *volume = UDISKS_LINUX_LOGICAL_VOLUME (_volume);
UDisksLinuxLogicalVolumeObject *object = NULL;
UDisksDaemon *daemon = NULL;
uid_t caller_uid;
gboolean teardown_flag = FALSE;
UDisksLinuxVolumeGroupObject *group_object;
LVJobData data;
g_variant_lookup (options, "tear-down", "b", &teardown_flag);
if (!common_setup (volume, invocation, options,
N_("Authentication is required to delete a logical volume"),
&object, &daemon, &caller_uid, NULL))
goto out;
if (teardown_flag &&
!teardown_logical_volume (_volume,
daemon,
invocation,
options,
&error))
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
group_object = udisks_linux_logical_volume_object_get_volume_group (object);
data.vg_name = udisks_linux_volume_group_object_get_name (group_object);
data.lv_name = udisks_linux_logical_volume_object_get_name (object);
if (!udisks_daemon_launch_threaded_job_sync (daemon,
UDISKS_OBJECT (object),
"lvm-lvol-delete",
caller_uid,
lvremove_job_func,
&data,
NULL, /* user_data_free_func */
NULL, /* GCancellable */
&error))
{
g_dbus_method_invocation_return_error (invocation,
UDISKS_ERROR,
UDISKS_ERROR_FAILED,
"Error deleting logical volume: %s",
error->message);
goto out;
}
udisks_logical_volume_complete_delete (_volume, invocation);
out:
g_clear_object (&object);
return TRUE;
}
static void __init tl_wdr4900_v2_setup(void)
{
ath79_register_gpio_keys_polled(-1, ARCHER_C7_KEYS_POLL_INTERVAL,
ARRAY_SIZE(archer_c7_gpio_keys),
archer_c7_gpio_keys);
common_setup(false);
}
static int make_graphpage_tex (void)
{
char *fname;
FILE *fp;
int err = 0;
fname = gpage_fname(".tex", 0);
fp = gretl_fopen(fname, "w");
if (fp == NULL) {
return 1;
}
doctop(fp);
err = geomline(gpage.ngraphs, fp);
if (!err) {
common_setup(fp);
err = tex_graph_setup(gpage.ngraphs, fp);
}
if (!err) {
common_end(fp);
}
fclose(fp);
return err;
}
static void __init archer_c5_setup(void)
{
ath79_register_gpio_keys_polled(-1, ARCHER_C7_KEYS_POLL_INTERVAL,
ARRAY_SIZE(archer_c7_gpio_keys),
archer_c7_gpio_keys);
common_setup(true);
}
/** @NAME: connect_to
* @DESC: Intenta establecer conexion con el servidor que deberia estar escuchando. Controla errores, vuelve cuando conecta
* @RETURN: Devuelve EXIT_FAILURE (1) si fallo la conexion, en otro caso devuelve el socket.
*
*/
int connect_to(char *IP, char* Port)
{
struct addrinfo* serverInfo = common_setup(IP, Port);
if (serverInfo == NULL )
{
return -1;
}
int serverSocket = socket(serverInfo->ai_family, serverInfo->ai_socktype,
serverInfo->ai_protocol);
if (serverSocket == -1)
{
error_show(
"\n No se pudo disponer de un socket al llamar connect_to, error: %d, man errno o internet!",
errno);
return -1;
}
if (connect(serverSocket, serverInfo->ai_addr, serverInfo->ai_addrlen)
== -1)
{
puts("\n");
error_show(
"No se pudo conectar con el proceso que hace de servidor, error: %d",
errno);
close(serverSocket);
return -1;
}
//char s[INET6_ADDRSTRLEN];
//inet_ntop(serverInfo->ai_family, get_in_addr((struct sockaddr *)serverInfo->ai_addr),s, sizeof s);
//printf("Conectando con %s\n", s);
freeaddrinfo(serverInfo);
return serverSocket;
}
int setup_server(struct addrinfo *server_addr)
{
int tSock = common_setup(server_addr);
if (tSock < 0)
{
perror("Error: Could not create server socket");
return ERROR;
}
int tEnable = 1;
setsockopt(tSock, SOL_SOCKET, SO_REUSEADDR, &tEnable, sizeof (tEnable));
if (bind(tSock, server_addr->ai_addr, server_addr->ai_addrlen) < 0)
{
close(tSock);
perror("Error: Could not bind socket");
return ERROR;
}
if (listen(tSock, 5) < 0)
{
close(tSock);
perror("Error: Unable to listen on server socket");
return ERROR;
}
return tSock;
}
static gboolean
handle_cache_detach_or_split (UDisksLogicalVolume *volume_,
GDBusMethodInvocation *invocation,
GVariant *options,
gboolean destroy)
{
#ifndef HAVE_LVMCACHE
g_dbus_method_invocation_return_error (invocation,
UDISKS_ERROR,
UDISKS_ERROR_FAILED,
N_("LVMCache not enabled at compile time."));
return TRUE;
#else
GError *error = NULL;
UDisksLinuxLogicalVolume *volume = UDISKS_LINUX_LOGICAL_VOLUME (volume_);
UDisksLinuxLogicalVolumeObject *object = NULL;
UDisksDaemon *daemon;
uid_t caller_uid;
UDisksLinuxVolumeGroupObject *group_object;
LVJobData data;
if (!common_setup (volume, invocation, options,
N_("Authentication is required to split cache pool LV off of a cache LV"),
&object, &daemon, &caller_uid, NULL))
goto out;
group_object = udisks_linux_logical_volume_object_get_volume_group (object);
data.vg_name = udisks_linux_volume_group_object_get_name (group_object);
data.lv_name = udisks_linux_logical_volume_object_get_name (object);
data.destroy = destroy;
if (!udisks_daemon_launch_threaded_job_sync (daemon,
UDISKS_OBJECT (object),
"lvm-lv-split-cache",
caller_uid,
lvcache_detach_job_func,
&data,
NULL, /* user_data_free_func */
NULL, /* GCancellable */
&error))
{
g_dbus_method_invocation_return_error (invocation,
UDISKS_ERROR,
UDISKS_ERROR_FAILED,
N_("Error converting volume: %s"),
error->message);
goto out;
}
udisks_logical_volume_complete_cache_split (volume_, invocation);
out:
g_clear_object (&object);
return TRUE;
#endif /* HAVE_LVMCACHE */
}
static gboolean
handle_rename (UDisksLogicalVolume *_volume,
GDBusMethodInvocation *invocation,
const gchar *new_name,
GVariant *options)
{
GError *error = NULL;
UDisksLinuxLogicalVolume *volume = UDISKS_LINUX_LOGICAL_VOLUME (_volume);
UDisksLinuxLogicalVolumeObject *object = NULL;
UDisksDaemon *daemon;
uid_t caller_uid;
UDisksLinuxVolumeGroupObject *group_object;
const gchar *lv_objpath;
LVJobData data;
if (!common_setup (volume, invocation, options,
N_("Authentication is required to rename a logical volume"),
&object, &daemon, &caller_uid, NULL))
goto out;
group_object = udisks_linux_logical_volume_object_get_volume_group (object);
data.vg_name = udisks_linux_volume_group_object_get_name (group_object);
data.lv_name = udisks_linux_logical_volume_object_get_name (object);
data.new_lv_name = new_name;
if (!udisks_daemon_launch_threaded_job_sync (daemon,
UDISKS_OBJECT (object),
"lvm-lvol-rename",
caller_uid,
lvrename_job_func,
&data,
NULL, /* user_data_free_func */
NULL, /* GCancellable */
&error))
{
g_dbus_method_invocation_return_error (invocation,
UDISKS_ERROR,
UDISKS_ERROR_FAILED,
"Error renaming logical volume: %s",
error->message);
goto out;
}
lv_objpath = wait_for_logical_volume_path (group_object, new_name, &error);
if (lv_objpath == NULL)
{
g_prefix_error (&error,
"Error waiting for logical volume object for %s",
new_name);
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
udisks_logical_volume_complete_rename (_volume, invocation, lv_objpath);
out:
g_clear_object (&object);
return TRUE;
}
static void __init tl_mr3040_setup(void)
{
common_setup();
ath79_register_gpio_keys_polled(-1, TL_MR11U_KEYS_POLL_INTERVAL,
1, tl_mr11u_gpio_keys);
gpio_request_one(TL_MR3040_GPIO_USB_POWER,
GPIOF_OUT_INIT_HIGH | GPIOF_EXPORT_DIR_FIXED,
"USB power");
}
int
client_setup(krb5_context *context, int *argc, char **argv)
{
int optidx = *argc;
int port = common_setup(context, &optidx, argv, client_usage);
if(*argc - optidx != 1)
client_usage(1, args, num_args);
*argc = optidx;
return port;
}
static void __init wr941ndv6_setup(void)
{
common_setup(false);
ath79_register_leds_gpio(-1, ARRAY_SIZE(wdr3500_leds_gpio) - 2,
wdr3500_leds_gpio);
ath79_register_gpio_keys_polled(-1, WDR3500_KEYS_POLL_INTERVAL,
ARRAY_SIZE(wr941ndv6_gpio_keys),
wr941ndv6_gpio_keys);
}
int setup_listen(char* Port)
{
struct addrinfo* serverInfo = common_setup("localhost", Port);
if (serverInfo == NULL )
return -1;
int socketEscucha;
socketEscucha = socket(serverInfo->ai_family, serverInfo->ai_socktype,
serverInfo->ai_protocol);
bind(socketEscucha, serverInfo->ai_addr, serverInfo->ai_addrlen);
freeaddrinfo(serverInfo);
return socketEscucha;
}
static gboolean
handle_resize (UDisksLogicalVolume *_volume,
GDBusMethodInvocation *invocation,
guint64 new_size,
GVariant *options)
{
GError *error = NULL;
UDisksLinuxLogicalVolume *volume = UDISKS_LINUX_LOGICAL_VOLUME (_volume);
UDisksLinuxLogicalVolumeObject *object = NULL;
UDisksDaemon *daemon;
uid_t caller_uid;
UDisksLinuxVolumeGroupObject *group_object;
LVJobData data;
if (!common_setup (volume, invocation, options,
N_("Authentication is required to resize a logical volume"),
&object, &daemon, &caller_uid, NULL))
goto out;
group_object = udisks_linux_logical_volume_object_get_volume_group (object);
data.vg_name = udisks_linux_volume_group_object_get_name (group_object);
data.lv_name = udisks_linux_logical_volume_object_get_name (object);
data.new_lv_size = new_size;
data.resize_fs = FALSE;
data.force = FALSE;
g_variant_lookup (options, "resize_fsys", "b", &(data.resize_fs));
g_variant_lookup (options, "force", "b", &(data.force));
if (!udisks_daemon_launch_threaded_job_sync (daemon,
UDISKS_OBJECT (object),
"lvm-lvol-resize",
caller_uid,
lvresize_job_func,
&data,
NULL, /* user_data_free_func */
NULL, /* GCancellable */
&error))
{
g_dbus_method_invocation_return_error (invocation,
UDISKS_ERROR,
UDISKS_ERROR_FAILED,
"Error resizing logical volume: %s",
error->message);
goto out;
}
udisks_logical_volume_complete_resize (_volume, invocation);
out:
g_clear_object (&object);
return TRUE;
}
static int server_connect(void)
{
int ret;
struct fi_cq_entry comp;
ret = common_setup();
if (ret != 0)
goto err;
do {
ret = fi_cq_read(rcq, &comp, 1);
if (ret < 0 && ret != -FI_EAGAIN) {
FT_PRINTERR("fi_cq_read", ret);
return ret;
}
} while (ret == -FI_EAGAIN);
ret = fi_av_insert(av, buf_ptr, 1, &remote_fi_addr, 0, NULL);
if (ret != 1) {
if (ret == 0) {
fprintf(stderr, "Unable to resolve remote address 0x%x 0x%x\n",
((uint32_t *)buf)[0], ((uint32_t *)buf)[1]);
ret = -FI_EINVAL;
} else {
FT_PRINTERR("fi_av_insert", ret);
}
goto err;
}
ret = fi_recv(ep, buf, buffer_size, fi_mr_desc(mr), 0, buf);
if (ret != 0) {
FT_PRINTERR("fi_recv", ret);
goto err;
}
ret = send_xfer(4);
if (ret != 0)
goto err;
return 0;
err:
free_ep_res();
if (dom)
fi_close(&dom->fid);
if (fab)
fi_close(&fab->fid);
return ret;
}
int
archive_write_add_filter_lzip(struct archive *_a)
{
struct archive_write_filter *f;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_lzip");
f = __archive_write_allocate_filter(_a);
r = common_setup(f);
if (r == ARCHIVE_OK) {
f->code = ARCHIVE_FILTER_LZIP;
f->name = "lzip";
}
return (r);
}
int
server_setup(krb5_context *context, int argc, char **argv)
{
int port = common_setup(context, &argc, argv, server_usage);
krb5_error_code ret;
if(argv[argc] != NULL)
server_usage(1, args, num_args);
if (keytab_str != NULL)
ret = krb5_kt_resolve (*context, keytab_str, &keytab);
else
ret = krb5_kt_default (*context, &keytab);
if (ret)
krb5_err (*context, 1, ret, "krb5_kt_resolve/default");
return port;
}
static int client_connect(void)
{
int ret;
socklen_t addrlen;
struct sockaddr *sin;
ret = common_setup();
if (ret != 0)
goto err;
ret = getaddr(dst_addr, port, (struct sockaddr **) &sin,
(socklen_t *) &addrlen);
if (ret != 0)
goto err;
ret = fi_connect(ep, sin, NULL, 0);
if (ret) {
printf("fi_connect %s\n", fi_strerror(-ret));
goto err;
}
// send initial message to server
ret = send_xfer(4);
if (ret != 0)
goto err;
// wait for reply to know server is ready
ret = recv_xfer(4);
if (ret != 0)
goto err;
return 0;
err:
free_ep_res();
fi_close(&av->fid);
fi_close(&ep->fid);
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
static int client_connect(void)
{
int ret;
ret = common_setup();
if (ret != 0)
return ret;
ret = ft_getdestaddr(opts.dst_addr, opts.dst_port, hints);
if (ret != 0)
goto err1;
ret = fi_av_insert(av, hints->dest_addr, 1, &remote_fi_addr, 0, NULL);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
goto err2;
}
// send initial message to server with our local address
memcpy(buf_ptr, fi->src_addr, fi->src_addrlen);
ret = send_xfer(fi->src_addrlen);
if (ret != 0)
goto err2;
// wait for reply to know server is ready
ret = recv_xfer(4);
if (ret != 0)
goto err2;
return 0;
err2:
free(hints->dest_addr);
err1:
free_ep_res();
fi_close(&av->fid);
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
static int server_connect(void)
{
int ret;
struct fi_cq_entry comp;
ret = common_setup();
if (ret != 0)
goto err;
do {
ret = fi_cq_readfrom(rcq, &comp, sizeof comp, &client_addr);
if (ret < 0) {
printf("RCQ readfrom %d (%s)\n", ret, fi_strerror(-ret));
return ret;
}
} while (ret == 0);
if (client_addr == FI_ADDR_NOTAVAIL) {
printf("Error getting address\n");
goto err;
}
ret = fi_recv(ep, buf, buffer_size, fi_mr_desc(mr), buf);
if (ret != 0) {
printf("fi_recv %d (%s)\n", ret, fi_strerror(-ret));
goto err;
}
ret = send_xfer(4);
if (ret != 0)
goto err;
return 0;
err:
free_ep_res();
fi_close(&ep->fid);
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
static void __init tl_wa901nd_setup(void)
{
u8 *mac = (u8 *) KSEG1ADDR(0x1f01fc00);
ath79_gpio_function_disable(AR724X_GPIO_FUNC_ETH_SWITCH_LED0_EN |
AR724X_GPIO_FUNC_ETH_SWITCH_LED1_EN |
AR724X_GPIO_FUNC_ETH_SWITCH_LED2_EN |
AR724X_GPIO_FUNC_ETH_SWITCH_LED3_EN |
AR724X_GPIO_FUNC_ETH_SWITCH_LED4_EN);
common_setup();
ath79_register_leds_gpio(-1, ARRAY_SIZE(tl_wa901nd_leds_gpio),
tl_wa901nd_leds_gpio);
ath79_register_gpio_keys_polled(-1, TL_WA901ND_KEYS_POLL_INTERVAL,
ARRAY_SIZE(tl_wa901nd_gpio_keys),
tl_wa901nd_gpio_keys);
tplink_register_ap91_wmac1(0x1000, mac, 0);
}
static void __init tl_mr10u_setup(void)
{
common_setup(TL_MR10U_GPIO_USB_POWER, false);
}
static void __init tl_wr710n_setup(void)
{
common_setup(TL_WR703N_GPIO_USB_POWER, true);
}
static void __init tl_wr703n_setup(void)
{
common_setup(TL_WR703N_GPIO_USB_POWER, false);
}
static gboolean
handle_activate (UDisksLogicalVolume *_volume,
GDBusMethodInvocation *invocation,
GVariant *options)
{
GError *error = NULL;
UDisksLinuxLogicalVolume *volume = UDISKS_LINUX_LOGICAL_VOLUME (_volume);
UDisksLinuxLogicalVolumeObject *object = NULL;
UDisksDaemon *daemon;
uid_t caller_uid;
UDisksLinuxVolumeGroupObject *group_object;
UDisksObject *block_object = NULL;
LVJobData data;
if (!common_setup (volume, invocation, options,
N_("Authentication is required to activate a logical volume"),
&object, &daemon, &caller_uid, NULL))
goto out;
group_object = udisks_linux_logical_volume_object_get_volume_group (object);
data.vg_name = udisks_linux_volume_group_object_get_name (group_object);
data.lv_name = udisks_linux_logical_volume_object_get_name (object);
if (!udisks_daemon_launch_threaded_job_sync (daemon,
UDISKS_OBJECT (object),
"lvm-lvol-activate",
caller_uid,
lvactivate_job_func,
&data,
NULL, /* user_data_free_func */
NULL, /* GCancellable */
&error))
{
g_dbus_method_invocation_return_error (invocation,
UDISKS_ERROR,
UDISKS_ERROR_FAILED,
"Error activating logical volume: %s",
error->message);
goto out;
}
block_object = udisks_daemon_wait_for_object_sync (daemon,
wait_for_logical_volume_block_object,
object,
NULL,
10, /* timeout_seconds */
&error);
if (block_object == NULL)
{
g_prefix_error (&error,
"Error waiting for block object for %s",
udisks_logical_volume_get_name (_volume));
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
udisks_logical_volume_complete_activate (_volume, invocation,
g_dbus_object_get_object_path (G_DBUS_OBJECT (block_object)));
out:
g_clear_object (&block_object);
g_clear_object (&object);
return TRUE;
}
ut_setup()
{
common_setup(BLOCKDEVICE_ACCESS_READ);
}
static void __init archer_c7_setup(void)
{
common_setup(true);
}
static void __init tl_wdr4900_v2_setup(void)
{
common_setup(false);
}
static void __init tl_wa7510n_v1_setup(void)
{
common_setup();
ath79_register_pci();
}
