QJsonObject festrip_api::user_update(QString password,
QString nickname,
QString twitterId,
QString name,
QString lastname,
QString gender,
QString countryId,
QString cityId,
QString avatar)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/user/")));
// Fill in query
query.addQueryItem("query", "update");
query.addQueryItem("token", token.toString());
query.addQueryItem("password", password);
query.addQueryItem("nickname", nickname);
query.addQueryItem("twitterId", twitterId);
query.addQueryItem("name", name);
query.addQueryItem("lastname", lastname);
query.addQueryItem("gender", gender);
query.addQueryItem("countryId", countryId);
query.addQueryItem("cityId", cityId);
query.addQueryItem("avatar", avatar);
// Send query to server
QJsonObject response = send_query(POST, query);
// Return JSON
return(response);
}
void send(DialogId dialog_id, MessageId message_id, const tl_object_ptr<td_api::CallbackQueryPayload> &payload,
int64 result_id) {
result_id_ = result_id;
dialog_id_ = dialog_id;
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
CHECK(input_peer != nullptr);
int32 flags = 0;
BufferSlice data;
CHECK(payload != nullptr);
switch (payload->get_id()) {
case td_api::callbackQueryPayloadData::ID:
flags = telegram_api::messages_getBotCallbackAnswer::DATA_MASK;
data = BufferSlice(static_cast<const td_api::callbackQueryPayloadData *>(payload.get())->data_);
break;
case td_api::callbackQueryPayloadGame::ID:
flags = telegram_api::messages_getBotCallbackAnswer::GAME_MASK;
break;
default:
UNREACHABLE();
}
auto net_query = G()->net_query_creator().create(create_storer(telegram_api::messages_getBotCallbackAnswer(
flags, false /*ignored*/, std::move(input_peer), message_id.get_server_message_id().get(), std::move(data))));
net_query->need_resend_on_503 = false;
send_query(std::move(net_query));
}
int main()
{
struct ifaddrs *ifaces = NULL;
fd_set fdset;
int maxfd = 0;
if (getifaddrs(&ifaces))
{
ROS_ERROR("Couldn't get interface list.");
return 1;
}
FD_ZERO(&fdset);
maxfd = receive_socket();
if (maxfd < 0)
return 1;
FD_SET(maxfd, &fdset);
int port = get_local_port(maxfd);
for (struct ifaddrs *curif = ifaces; curif; curif = curif->ifa_next)
{
if (curif->ifa_addr && curif->ifa_addr->sa_family == AF_INET)
send_query(curif, port);
}
freeifaddrs(ifaces);
return collect_replies(&fdset, maxfd) != 0;
}
int UpdateQuery()
{
int i;
timediff_t t, min = Timeout;
struct queries *q;
int free = 0;
if (!finished && TimeLimit > 0) {
if ((t = timediff(¤t, &start)) > TimeLimit * 1000000LL) {
finished = 1;
send_finished = current;
}
}
for(i = 0; i < nQueries; i++) {
q = &Queries[i];
if (q->sent_flag) {
if ((t = timediff(¤t, &q->sent)) > Timeout) {
/* timeouted */
register_response(q, TIMEOUTERROR, "UpdateQuery");
tcp_close(q);
} else
if (t < min)
min = t;
}
if (!q->sent_flag) {
if (!finished)
send_query(q);
else
free++;
}
}
if (free == nQueries)
min = -1; /* finished */
return min;
}
ret_t
cherokee_handler_dbslayer_init (cherokee_handler_dbslayer_t *hdl)
{
ret_t ret;
cherokee_connection_t *conn = HANDLER_CONN(hdl);
cherokee_handler_dbslayer_props_t *props = HANDLER_DBSLAYER_PROPS(hdl);
/* Check client headers
*/
cherokee_client_headers (hdl);
/* Get a reference to the target host
*/
if (hdl->src_ref == NULL) {
ret = cherokee_balancer_dispatch (props->balancer, conn, &hdl->src_ref);
if (ret != ret_ok)
return ret;
}
/* Connect to the MySQL server
*/
ret = connect_to_database(hdl);
if (unlikely (ret != ret_ok))
return ret;
/* Send query:
* Do not check whether it failed, ::step() will do
* it and send an error message if needed.
*/
send_query(hdl);
return ret_ok;
}
void sql_database::async_send_query(boost::asio::io_service::work &,
sql_callback cb, const query_list & sql)
{
auto & c = get_free_connection();
auto guard = make_guard(std::bind(&std::mutex::unlock, &c.lock));
std::string error;
auto qres = std::make_shared<query_result>(send_query(c, sql, error));
_main_service.post(std::bind(cb, std::move(qres), error));
}
void AtlasDo::update() {
if (_waiting_for_response) {
if (millis() - _time_of_last_query > 1800) {
read_response();
}
}
else if (millis() - _time_of_last_query > _min_update_interval) {
send_query();
}
}
QJsonObject festrip_api::user_attended_festivals()
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/user/")));
// Fill in query
query.addQueryItem("query", "attended_festivals");
query.addQueryItem("token", token.toString());
// Send query to server
QJsonObject response = send_query(POST, query);
// Return JSON
return(response);
}
// Updates API
QJsonObject festrip_api::updates_get_updates(QDate date)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/updates/")));
// Fill in query
query.addQueryItem("query", "get_updates");
query.addQueryItem("token", token.toString());
query.addQueryItem("date", date.toString());
// Send query to server
QJsonObject response = send_query(GET, query);
// Return JSON
return(response);
}
// Game API
QJsonObject festrip_api::game_get_badges(QString type)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/game/")));
// Fill in query
query.addQueryItem("query", "get_badges");
query.addQueryItem("token", token.toString());
query.addQueryItem("type", type);
// Send query to server
QJsonObject response = send_query(GET, query);
// Return JSON
return(response);
}
QJsonObject festrip_api::group_festival(int festivalId)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/group/")));
// Fill in query
query.addQueryItem("query", "festival");
query.addQueryItem("token", token.toString());
query.addQueryItem("festival_id", QString::number(festivalId));
// Send query to server
QJsonObject response = send_query(POST, query);
// Return JSON
return(response);
}
QJsonObject festrip_api::user_get_public_info(int userId)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/user/")));
// Fill in query
query.addQueryItem("query", "get_public_info");
query.addQueryItem("token", token.toString());
query.addQueryItem("userId", (QString)(userId));
// Send query to server
QJsonObject response = send_query(GET, query);
// Return JSON
return(response);
}
QJsonObject festrip_api::user_reset_password(QString username)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/user/")));
// Fill in query
query.addQueryItem("query", "reset_password");
query.addQueryItem("username", username);
query.addQueryItem("token", token.toString());
// Send query to server
QJsonObject response = send_query(GET, query);
// Return JSON
return(response);
}
query_result sql_database::query(const query_list & sql)
{
if (sql.empty())
return { };
auto & c = get_free_connection();
auto guard = make_guard(std::bind(&std::mutex::unlock, &c.lock));
std::string error;
auto result = send_query(c, sql, error);
if (!error.empty())
throw sql_error { error.c_str() };
return result;
}
// Festival API
QJsonObject festrip_api::festival_list(int indexStart, int amount)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/festival/")));
// Fill in query
query.addQueryItem("query", "list");
query.addQueryItem("token", token.toString());
query.addQueryItem('from', QString::number(indexStart));
query.addQueryItem("amount", QString::number(amount));
// Send query to server
QJsonObject response = send_query(GET, query);
// Return JSON
return(response);
}
QJsonObject festrip_api::festival_upload_pic(int festivalId, QString pic)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/festival/")));
// Fill in query
query.addQueryItem("query", "upload_pic");
query.addQueryItem("token", token.toString());
query.addQueryItem("festival_id", QString::number(festivalId));
query.addQueryItem("image", pic);
// Send query to server
QJsonObject response = send_query(POST, query);
// Return JSON
return(response);
}
// Comment API
QJsonObject festrip_api::comment_request(QString typeComment, int festivalId)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/comment/")));
// Fill in query
query.addQueryItem("query", "request");
query.addQueryItem("token", token.toString());
query.addQueryItem("type", typeComment);
query.addQueryItem("receiver_id", QString::number(festivalId));
// Send query to server
QJsonObject response = send_query(POST, query);
// Return JSON
return(response);
}
QJsonObject festrip_api::user_create(QString username, QString password, QString nickname)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/user/")));
// Fill in query
query.addQueryItem("query", "create");
query.addQueryItem("user", username);
query.addQueryItem("pass", password);
query.addQueryItem("nick", nickname);
// Send query to server
QJsonObject response = send_query(POST, query);
// Return JSON
return(response);
}
static void process_updates(struct sa_db_port *port)
{
struct update_info *update;
struct ib_sa_attr_list *attr_list;
int ret;
if (!paths_per_dest || update_port_info(port)) {
cleanup_port(port);
goto out;
}
/* Event registration is an optimization, so ignore failures. */
if (subscribe_inform_info) {
if (!port->out_info) {
ret = reg_out_info(port);
if (!ret)
return;
}
if (!port->in_info) {
ret = reg_in_info(port);
if (!ret)
return;
}
} else
unsubscribe_port(port);
while (!list_empty(&port->update_list)) {
update = list_entry(port->update_list.next,
struct update_info, list);
if (update->type == SA_UPDATE_REMOVE) {
write_lock_irq(&rwlock);
attr_list = find_attr_list(&port->paths,
update->gid.raw);
if (attr_list)
remove_attr(&port->paths, attr_list);
write_unlock_irq(&rwlock);
} else {
ret = send_query(port, update);
if (!ret)
return;
}
list_del(&update->list);
kfree(update);
}
out:
port->state = SA_DB_IDLE;
}
QJsonObject festrip_api::festival_checkin_empty(int festivalId, int userId)
{
QUrlQuery query = QUrlQuery(QUrl(QString(FESTRIP_URL).append("/api/festival/")));
// Fill in query
query.addQueryItem("query", "checkin");
query.addQueryItem("token", token.toString());
query.addQueryItem("festival_id", QString::number(festivalId));
query.addQueryItem("userId", QString::number(userId));
query.addQueryItem("check_in_status", QString::number(0));
// Send query to server
QJsonObject response = send_query(POST, query);
// Return JSON
return(response);
}
void keyPressed()
{
if(keyCode==UP)
send_command(FORWARD, linear_parameter1, linear_parameter2);
if(keyCode==DOWN)
send_command(BACKWARD, linear_parameter1, linear_parameter2);
if(keyCode==LEFT)
send_command(right, rotary_parameter1, rotary_parameter2);
if(keyCode==RIGHT)
send_command(left, rotary_parameter1, rotary_parameter2);
if(key=='c')
{
for(int i=0;i<100;i++)
{
send_command(FORWARD,linear_parameter1,linear_parameter2);
delay(1000);
send_command(left, rotary_parameter1, rotary_parameter2);
delay(1000);
if(pen)
{
pen_up();
}
else
pen_down();
pen=!pen;
delay(750);
check_data();
}
}
if(key=='?')
{
send_query(GET_STATUS);
}
if(key=='q')
{
exit();
}
if(key=='u')
pen_up();
if(key=='d')
pen_down();
if(key==' ')
send_command(STOP,(byte)0,(byte)0);
// if(key==' ')
// send_stop();
}
static bool
send_query(struct tcb *tcp, const int fd, void *req, size_t req_size)
{
struct sockaddr_nl nladdr = {
.nl_family = AF_NETLINK
};
struct iovec iov = {
.iov_base = req,
.iov_len = req_size
};
const struct msghdr msg = {
.msg_name = &nladdr,
.msg_namelen = sizeof(nladdr),
.msg_iov = &iov,
.msg_iovlen = 1
};
for (;;) {
if (sendmsg(fd, &msg, 0) < 0) {
if (errno == EINTR)
continue;
return false;
}
return true;
}
}
static bool
inet_send_query(struct tcb *tcp, const int fd, const int family,
const int proto)
{
struct {
const struct nlmsghdr nlh;
const struct inet_diag_req_v2 idr;
} req = {
.nlh = {
.nlmsg_len = sizeof(req),
.nlmsg_type = SOCK_DIAG_BY_FAMILY,
.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST
},
.idr = {
.sdiag_family = family,
.sdiag_protocol = proto,
.idiag_states = -1
}
};
return send_query(tcp, fd, &req, sizeof(req));
}
/*
*
* Function: main()
*
*/
int
main(int argc, char *argv[])
{
struct igmp_info mcast_rcv;
int background = 0;
debug = 0;
program_name = strdup(argv[0]);
memset(&mcast_rcv, '\0', sizeof(struct igmp_info));
parse_options(argc, argv, &mcast_rcv, &background);
if (background) /* Work in the background */
if (daemon(0, 0) < 0)
fatal_error("daemon()");
send_query(&mcast_rcv);
exit(EXIT_SUCCESS);
}
int pwrMeter::read_data(void)
{
int ret;
crcdata crcnow;
delay(1800);
Tx_Buffer[0]=Read_ID;
Tx_Buffer[1]=0x03;
Tx_Buffer[2]=0x00;
Tx_Buffer[3]=0x48;
Tx_Buffer[4]=0x00;
Tx_Buffer[5]=0x06;
crcnow.word16=chkcrc(Tx_Buffer,6);
Tx_Buffer[6]=crcnow.byte[1]; //CRC
Tx_Buffer[7]=crcnow.byte[0];
ret= send_query(Tx_Buffer, TX_BUFFER_SIZE);
#ifdef DEBUGGING
Serial.println("has incoming data");
#endif
return ret;
}
void module_exec_ui(module_info * mod) {
if(mod == NULL)
return;
/**Record the start time*/
time(&(mod->start_time));
if(!is_local_module(mod)) {
/**Special deal with Camera case*/
if(is_camera_module(mod)) {
cam_prepare_preview(mod);
}
/**Query extra command*/
if(mod->extracmd.is_valid == false)
send_query(mod);
send_run_mmi(mod);
create_module_indication_thread(mod);
} else {
create_module_thread(mod);
}
}
/**
* Send query to op's socket to get player name.
* @param op Object to send the query to. */
void get_name(object *op)
{
CONTR(op)->write_buf[0] = '\0';
CONTR(op)->state = ST_GET_NAME;
send_query(&CONTR(op)->socket, 0, "What is your name?\n:");
}
/**
* Send query to op's socket to get player's password.
* @param op Object to send the query to. */
void get_password(object *op)
{
CONTR(op)->write_buf[0] = '\0';
CONTR(op)->state = ST_GET_PASSWORD;
send_query(&CONTR(op)->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:");
}
/**
* If this is a new character, we will need to confirm the password.
* @param op Object to send the query to. */
void confirm_password(object *op)
{
CONTR(op)->write_buf[0] = '\0';
CONTR(op)->state = ST_CONFIRM_PASSWORD;
send_query(&CONTR(op)->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
}
int main (int argc, char *argv[])
{
int fd;
int opt;
int error;
int errorcount = 0;
int rawvalues[RESULT_SIZE];
char *tty = DEFAULT_TTY;
bool starttest = false;
bool aborttest = false;
bool switchbeep = false;
struct smsstatus results;
/***************************************************************************
* UPS QUERIES START
***************************************************************************/
/* Interrupt the battery test. No return. */
int query1[QUERY_SIZE] ={'\x44', /* D */
'\xff',
'\xff',
'\xff',
'\xff',
'\xc0',
'\x0d'};
/* Return strange values
* 0x3b (;), 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
* 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe5, 0x0d;
*/
int query2[QUERY_SIZE] ={'\x46', /* F */
'\xff',
'\xff',
'\xff',
'\xff',
'\xbe',
'\x0d'};
/* Does nothing? */
int query3[QUERY_SIZE] ={'\x47', /* G */
'\x01',
'\xff',
'\xff',
'\xff',
'\xbb',
'\x0d'};
/* Return model name and firmware version?
* 0x3a (:), 0x53 (S), 0x45 (E), 0x4e (N), 0x4f (O), 0x49 (I),
* 0x44 (D), 0x41 (A), 0x4c (L), 0x20, 0x20, 0x20, 0x20, 0x37 (7),
* 0x2e (.), 0x30 (0), 0x62 (b), 0x0d;
*/
int query4[QUERY_SIZE] ={'\x49', /* I */
'\xff',
'\xff',
'\xff',
'\xff',
'\xbb',
'\x0d'};
/* Switch the buzzer ON/OFF. No return. */
int query5[QUERY_SIZE] ={'\x4d', /* M */
'\xff',
'\xff',
'\xff',
'\xff',
'\xb7',
'\x0d'};
/* Return standard values
* 0x3d (=) - Just a mark
* 0x08 - 0XAA -
* 0x34 (4) - 0X AA - lastinputVac
* 0x08 - 0XBB -
* 0x34 (4) - 0X BB - inputVac
* 0x04 - 0XCC -
* 0x38 (8) - 0X CC - outputVac
* 0x01 - 0XDD -
* 0x22 (") - 0X DD - outputpower
* 0x02 - 0XEE -
* 0x58 (X) - 0X EE - outputHz
* 0x03 - 0XFF -
* 0xe8 - 0X FF - batterylevel
* 0x01 - 0XGG -
* 0x7c (|) - 0X GG - temperatureC
* 0x29 ()) - HH - State bits (beepon, shutdown, test, upsok,
* 0x01 - ?? - ?? boost, onacpower, lowbattery, onbattery)
* 0x0d - Just a mark
*/
int query6[QUERY_SIZE] ={'\x51', /* Q */
'\xff',
'\xff',
'\xff',
'\xff',
'\xb3',
'\x0d'};
/* Test the battery for 10 seconds. No return. */
int query7[QUERY_SIZE] ={'\x54', /* T */
'\x00',
'\x10',
'\x00',
'\x00',
'\x9c',
'\x0d'};
/***************************************************************************
* UPS QUERIES END
***************************************************************************/
/* Command line parser */
while ((opt = getopt(argc, argv, "abst:")) != -1) {
switch (opt) {
case 'a':
aborttest = true;
break;
case 'b':
switchbeep = true;
break;
case 's':
starttest = true;
break;
case 't':
tty = optarg;
break;
default: /* '?' */
fprintf(stderr, "Usage: %s\n\t-s: Start battery test\n\t-a: "
"Abort battery test\n\t-b: Switch buzzer ON/OFF\n\t-t: Path to TTY (Ex: /dev/ttyUSB0)\n", argv[0]);
exit(EXIT_FAILURE);
}
}
/* Avoid calling start and abort battery test simultaneosly */
if (starttest && aborttest){
printf ("ERROR: Can't start and abort battery test at same time.\n");
exit(EXIT_FAILURE);
}
if ( (fd = open_config_tty(tty)) < 0){
perror("open_port: Unable to open DEFAULT_TTY - ");
return -1;
}
if (switchbeep)
send_query (fd, query5);
if (starttest)
send_query (fd, query7);
if (aborttest)
send_query (fd, query1);
/* Device Startup
* This is done on the official software but looks not necessary
*
send_query (fd, query3);
send_query (fd, query4);
get_results2(fd, rawvalues);
send_query (fd, query4);
get_results2(fd, rawvalues);
send_query (fd, query2);
get_results2(fd, rawvalues);
send_query (fd, query6);
get_results2(fd, rawvalues);
*/
while (errorcount < 2 ){
send_query (fd, query6);
if (get_results2(fd, rawvalues) < 0){
perror("Error reading tty. ");
return -1;
}
// printf("Errorcount: %d\n", errorcount);
if ((error = check_results(rawvalues)) > 0){
// printf("Error: %d\n", error);
errorcount++;
usleep (250000);
continue;
} else
break;
}
if (errorcount > 1){
perror("get_results: tty was opened but is sending incorrect values - ");
return error;
}
results_to_human(rawvalues, &results);
close_tty(fd);
print_values(&results);
exit(EXIT_SUCCESS);
}
static bool
receive_responses(struct tcb *tcp, const int fd, const unsigned long inode,
const unsigned long expected_msg_type,
int (*parser)(const void *, int,
unsigned long, void *),
void *opaque_data)
{
static union {
struct nlmsghdr hdr;
long buf[8192 / sizeof(long)];
} hdr_buf;
struct sockaddr_nl nladdr = {
.nl_family = AF_NETLINK
};
struct iovec iov = {
.iov_base = hdr_buf.buf,
.iov_len = sizeof(hdr_buf.buf)
};
int flags = 0;
for (;;) {
struct msghdr msg = {
.msg_name = &nladdr,
.msg_namelen = sizeof(nladdr),
.msg_iov = &iov,
.msg_iovlen = 1
};
ssize_t ret = recvmsg(fd, &msg, flags);
if (ret < 0) {
if (errno == EINTR)
continue;
return false;
}
const struct nlmsghdr *h = &hdr_buf.hdr;
if (!NLMSG_OK(h, ret))
return false;
for (; NLMSG_OK(h, ret); h = NLMSG_NEXT(h, ret)) {
if (h->nlmsg_type != expected_msg_type)
return false;
const int rc = parser(NLMSG_DATA(h),
h->nlmsg_len, inode, opaque_data);
if (rc > 0)
return true;
if (rc < 0)
return false;
}
flags = MSG_DONTWAIT;
}
}
static bool
unix_send_query(struct tcb *tcp, const int fd, const unsigned long inode)
{
struct {
const struct nlmsghdr nlh;
const struct unix_diag_req udr;
} req = {
.nlh = {
.nlmsg_len = sizeof(req),
.nlmsg_type = SOCK_DIAG_BY_FAMILY,
.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST
},
.udr = {
.sdiag_family = AF_UNIX,
.udiag_ino = inode,
.udiag_states = -1,
.udiag_show = UDIAG_SHOW_NAME | UDIAG_SHOW_PEER
}
};
return send_query(tcp, fd, &req, sizeof(req));
}
static int
unix_parse_response(const void *data, const int data_len,
const unsigned long inode, void *opaque_data)
{
const char *proto_name = opaque_data;
const struct unix_diag_msg *diag_msg = data;
struct rtattr *attr;
int rta_len = data_len - NLMSG_LENGTH(sizeof(*diag_msg));
uint32_t peer = 0;
size_t path_len = 0;
char path[UNIX_PATH_MAX + 1];
if (rta_len < 0)
return -1;
if (diag_msg->udiag_ino != inode)
return 0;
if (diag_msg->udiag_family != AF_UNIX)
return -1;
for (attr = (struct rtattr *) (diag_msg + 1);
RTA_OK(attr, rta_len);
attr = RTA_NEXT(attr, rta_len)) {
switch (attr->rta_type) {
case UNIX_DIAG_NAME:
if (!path_len) {
path_len = RTA_PAYLOAD(attr);
if (path_len > UNIX_PATH_MAX)
path_len = UNIX_PATH_MAX;
memcpy(path, RTA_DATA(attr), path_len);
path[path_len] = '\0';
}
break;
case UNIX_DIAG_PEER:
if (RTA_PAYLOAD(attr) >= 4)
peer = *(uint32_t *) RTA_DATA(attr);
break;
}
}
/*
* print obtained information in the following format:
* "UNIX:[" SELF_INODE [ "->" PEER_INODE ][ "," SOCKET_FILE ] "]"
*/
if (!peer && !path_len)
return -1;
char peer_str[3 + sizeof(peer) * 3];
if (peer)
xsprintf(peer_str, "->%u", peer);
else
peer_str[0] = '\0';
const char *path_str;
if (path_len) {
char *outstr = alloca(4 * path_len + 4);
outstr[0] = ',';
if (path[0] == '\0') {
outstr[1] = '@';
string_quote(path + 1, outstr + 2,
path_len - 1, QUOTE_0_TERMINATED);
} else {
string_quote(path, outstr + 1,
path_len, QUOTE_0_TERMINATED);
}
path_str = outstr;
} else {
path_str = "";
}
char *details;
if (asprintf(&details, "%s:[%lu%s%s]", proto_name, inode,
peer_str, path_str) < 0)
return -1;
return cache_inode_details(inode, details);
}
static bool
netlink_send_query(struct tcb *tcp, const int fd, const unsigned long inode)
{
struct {
const struct nlmsghdr nlh;
const struct netlink_diag_req ndr;
} req = {
.nlh = {
.nlmsg_len = sizeof(req),
.nlmsg_type = SOCK_DIAG_BY_FAMILY,
.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST
},
.ndr = {
.sdiag_family = AF_NETLINK,
.sdiag_protocol = NDIAG_PROTO_ALL,
.ndiag_show = NDIAG_SHOW_MEMINFO
}
};
return send_query(tcp, fd, &req, sizeof(req));
}
