static void
watch_killer(NautilusDropboxHookserv *hookserv) {
debug("hook client disconnected");
hookserv->connected = FALSE;
g_hook_list_invoke(&(hookserv->ondisconnect_hooklist), FALSE);
/* we basically just have to free the memory allocated in the
handle_hook_server_init ctx */
if (hookserv->hhsi.command_name != NULL) {
g_free(hookserv->hhsi.command_name);
hookserv->hhsi.command_name = NULL;
}
if (hookserv->hhsi.command_args != NULL) {
g_hash_table_unref(hookserv->hhsi.command_args);
hookserv->hhsi.command_args = NULL;
}
g_io_channel_unref(hookserv->chan);
hookserv->chan = NULL;
hookserv->event_source = 0;
hookserv->socket = 0;
/* lol we also have to start a new connection */
try_to_connect(hookserv);
}
void MainWindow::repeat_connect()
{
if (m_connected_clicked)
{
if (!m_connected)
{
disconnect();
try_to_connect(m_server_address, m_server_port);
}
}
}
/**************************************************************************
Connect to a freeciv-server instance -- or at least try to. On success,
return 0; on failure, put an error message in ERRBUF and return -1.
**************************************************************************/
int connect_to_server(const char *username, const char *hostname, int port,
char *errbuf, int errbufsize)
{
if (0 != get_server_address(hostname, port, errbuf, errbufsize)) {
return -1;
}
if (0 != try_to_connect(username, errbuf, errbufsize)) {
return -1;
}
return 0;
}
/**************************************************************************
Make an attempt to autoconnect to the server.
It returns number of seconds it should be called again.
**************************************************************************/
double try_to_autoconnect(void)
{
char errbuf[512];
static int count = 0;
#ifndef WIN32_NATIVE
static int warning_shown = 0;
#endif
if (!autoconnecting) {
return FC_INFINITY;
}
count++;
if (count >= MAX_AUTOCONNECT_ATTEMPTS) {
freelog(LOG_FATAL,
_("Failed to contact server \"%s\" at port "
"%d as \"%s\" after %d attempts"),
server_host, server_port, user_name, count);
exit(EXIT_FAILURE);
}
switch (try_to_connect(user_name, errbuf, sizeof(errbuf))) {
case 0: /* Success! */
/* Don't call me again */
autoconnecting = FALSE;
return FC_INFINITY;
#ifndef WIN32_NATIVE
/* See PR#4042 for more info on issues with try_to_connect() and errno. */
case ECONNREFUSED: /* Server not available (yet) */
if (!warning_shown) {
freelog(LOG_ERROR, "Connection to server refused. "
"Please start the server.");
output_window_append(FTC_CLIENT_INFO, NULL,
_("Connection to server refused. "
"Please start the server."));
warning_shown = 1;
}
/* Try again in 0.5 seconds */
return 0.001 * AUTOCONNECT_INTERVAL;
#endif
default: /* All other errors are fatal */
freelog(LOG_FATAL,
_("Error contacting server \"%s\" at port %d "
"as \"%s\":\n %s\n"),
server_host, server_port, user_name, errbuf);
exit(EXIT_FAILURE);
}
}
void MainWindow::connect_clicked()
{
ui->actionConnect->setEnabled(false);
ui->actionDisconnect->setEnabled(true);
m_connected_clicked = true;
//TODO: Чтение из гуи
m_server_address = QHostAddress::LocalHost;
m_server_port = 10000;
QTime midnight(0,0,0);
qsrand(midnight.secsTo(QTime::currentTime()));
QString nickname = "User" + QString::number(qrand() % 10000);
set_nickname(nickname);
try_to_connect(m_server_address, m_server_port);
QTimer *timer = new QTimer(this);
QObject::connect(timer, SIGNAL(timeout()), this, SLOT(repeat_connect()));
timer->start(2000);
}
void list_file(struct s_static_client *br)
{
ssize_t octet;
char buffer[BUF_SIZE];
char message[CMD];
if (get_dataconnection_port(br) == -1)
return ;
xwrite(br->s_fd, "LIST", 4);
if (try_to_connect(br) == -1)
return ;
show_response_complete(message, br);
my_putstr("\n");
while ((octet = recv(br->pasv, buffer, BUF_SIZE, 0)) > 0)
xwrite(1, buffer, octet);
my_putstr("\n");
if (octet == -1)
my_putstr("ERROR : Error during data transfer\n");
xclose(br->pasv);
br->retrieve = -1;
br->pasv = -1;
}
void
nautilus_dropbox_hooks_start(NautilusDropboxHookserv *hookserv) {
try_to_connect(hookserv);
}
static void publisher(void)
{
int i, rc;
/* Set everything to 0 and later just assign the required fields. */
memset(&client_ctx, 0x00, sizeof(client_ctx));
/* connect, disconnect and malformed may be set to NULL */
client_ctx.mqtt_ctx.connect = connect_cb;
client_ctx.mqtt_ctx.disconnect = disconnect_cb;
client_ctx.mqtt_ctx.malformed = malformed_cb;
client_ctx.mqtt_ctx.net_init_timeout = APP_NET_INIT_TIMEOUT;
client_ctx.mqtt_ctx.net_timeout = APP_TX_RX_TIMEOUT;
client_ctx.mqtt_ctx.peer_addr_str = SERVER_ADDR;
client_ctx.mqtt_ctx.peer_port = SERVER_PORT;
#if defined(CONFIG_MQTT_LIB_TLS)
/** TLS setup */
client_ctx.mqtt_ctx.request_buf = tls_request_buf;
client_ctx.mqtt_ctx.request_buf_len = TLS_REQUEST_BUF_SIZE;
client_ctx.mqtt_ctx.personalization_data = TLS_PRIVATE_DATA;
client_ctx.mqtt_ctx.personalization_data_len = strlen(TLS_PRIVATE_DATA);
client_ctx.mqtt_ctx.cert_host = TLS_SNI_HOSTNAME;
client_ctx.mqtt_ctx.tls_mem_pool = &tls_mem_pool;
client_ctx.mqtt_ctx.tls_stack = tls_stack;
client_ctx.mqtt_ctx.tls_stack_size = K_THREAD_STACK_SIZEOF(tls_stack);
client_ctx.mqtt_ctx.cert_cb = setup_cert;
client_ctx.mqtt_ctx.entropy_src_cb = NULL;
#endif
/* Publisher apps TX the MQTT PUBLISH msg */
client_ctx.mqtt_ctx.publish_tx = publish_cb;
/* The connect message will be sent to the MQTT server (broker).
* If clean_session here is 0, the mqtt_ctx clean_session variable
* will be set to 0 also. Please don't do that, set always to 1.
* Clean session = 0 is not yet supported.
*/
client_ctx.connect_msg.client_id = MQTT_CLIENTID;
client_ctx.connect_msg.client_id_len = strlen(MQTT_CLIENTID);
client_ctx.connect_msg.clean_session = 1;
client_ctx.connect_data = "CONNECTED";
client_ctx.disconnect_data = "DISCONNECTED";
client_ctx.publish_data = "PUBLISH";
rc = network_setup();
PRINT_RESULT("network_setup", rc);
if (rc < 0) {
return;
}
rc = mqtt_init(&client_ctx.mqtt_ctx, MQTT_APP_PUBLISHER);
PRINT_RESULT("mqtt_init", rc);
if (rc != 0) {
return;
}
for (i = 0; i < CONN_TRIES; i++) {
rc = mqtt_connect(&client_ctx.mqtt_ctx);
PRINT_RESULT("mqtt_connect", rc);
if (!rc) {
goto connected;
}
}
goto exit_app;
connected:
rc = try_to_connect(&client_ctx);
PRINT_RESULT("try_to_connect", rc);
if (rc != 0) {
goto exit_app;
}
i = 0;
while (i++ < APP_MAX_ITERATIONS) {
rc = mqtt_tx_pingreq(&client_ctx.mqtt_ctx);
k_sleep(APP_SLEEP_MSECS);
PRINT_RESULT("mqtt_tx_pingreq", rc);
prepare_mqtt_publish_msg(&client_ctx.pub_msg, MQTT_QoS0);
rc = mqtt_tx_publish(&client_ctx.mqtt_ctx, &client_ctx.pub_msg);
k_sleep(APP_SLEEP_MSECS);
PRINT_RESULT("mqtt_tx_publish", rc);
prepare_mqtt_publish_msg(&client_ctx.pub_msg, MQTT_QoS1);
rc = mqtt_tx_publish(&client_ctx.mqtt_ctx, &client_ctx.pub_msg);
k_sleep(APP_SLEEP_MSECS);
PRINT_RESULT("mqtt_tx_publish", rc);
prepare_mqtt_publish_msg(&client_ctx.pub_msg, MQTT_QoS2);
rc = mqtt_tx_publish(&client_ctx.mqtt_ctx, &client_ctx.pub_msg);
k_sleep(APP_SLEEP_MSECS);
PRINT_RESULT("mqtt_tx_publish", rc);
}
rc = mqtt_tx_disconnect(&client_ctx.mqtt_ctx);
PRINT_RESULT("mqtt_tx_disconnect", rc);
exit_app:
mqtt_close(&client_ctx.mqtt_ctx);
printk("\nBye!\n");
}
