void
nk_uuid_update_string(NkUuid *self)
{
uuid_unparse_lower(self->data, self->string);
}
static int ping_icmp_handler(eventer_t e, int mask,
void *closure, struct timeval *now) {
noit_module_t *self = (noit_module_t *)closure;
ping_icmp_data_t *ping_data;
struct check_info *data;
char packet[1500];
int packet_len = sizeof(packet);
union {
struct sockaddr_in in4;
struct sockaddr_in6 in6;
} from;
unsigned int from_len;
struct ip *ip = (struct ip *)packet;
struct icmp *icp;
struct ping_payload *payload;
ping_data = noit_module_get_userdata(self);
while(1) {
struct ping_session_key k;
int inlen, iphlen;
void *vcheck;
noit_check_t *check;
struct timeval tt;
from_len = sizeof(from);
inlen = recvfrom(e->fd, packet, packet_len, 0,
(struct sockaddr *)&from, &from_len);
gettimeofday(now, NULL); /* set it, as we care about accuracy */
if(inlen < 0) {
if(errno == EAGAIN || errno == EINTR) break;
noitLT(nlerr, now, "ping_icmp recvfrom: %s\n", strerror(errno));
break;
}
iphlen = ip->ip_hl << 2;
if((inlen-iphlen) != (sizeof(struct icmp)+sizeof(struct ping_payload))) {
noitLT(nldeb, now,
"ping_icmp bad size: %d+%d\n", iphlen, inlen-iphlen);
continue;
}
icp = (struct icmp *)(packet + iphlen);
payload = (struct ping_payload *)(icp + 1);
if(icp->icmp_type != ICMP_ECHOREPLY) {
continue;
}
if(icp->icmp_id != (((vpsized_uint)self) & 0xffff)) {
noitLT(nlerr, now,
"ping_icmp not sent from this instance (%d:%d) vs. %lu\n",
icp->icmp_id, ntohs(icp->icmp_seq),
(unsigned long)(((vpsized_uint)self) & 0xffff));
continue;
}
check = NULL;
k.addr_of_check = payload->addr_of_check;
uuid_copy(k.checkid, payload->checkid);
if(noit_hash_retrieve(ping_data->in_flight,
(const char *)&k, sizeof(k),
&vcheck))
check = vcheck;
/* make sure this check is from this generation! */
if(!check) {
char uuid_str[37];
uuid_unparse_lower(payload->checkid, uuid_str);
noitLT(nldeb, now,
"ping_icmp response for unknown check '%s'\n", uuid_str);
continue;
}
if(check->generation != payload->generation) {
noitLT(nldeb, now,
"ping_icmp response in generation gap\n");
continue;
}
data = (struct check_info *)check->closure;
/* If there is no timeout_event, the check must have completed.
* We have nothing to do. */
if(!data->timeout_event) continue;
/* Sanity check the payload */
if(payload->check_no != data->check_no) continue;
if(payload->check_pack_cnt != data->expected_count) continue;
if(payload->check_pack_no < 0 ||
payload->check_pack_no >= data->expected_count) continue;
sub_timeval(*now, payload->whence, &tt);
data->turnaround[payload->check_pack_no] =
(float)tt.tv_sec + (float)tt.tv_usec / 1000000.0;
if(ping_icmp_is_complete(self, check)) {
ping_icmp_log_results(self, check);
eventer_remove(data->timeout_event);
free(data->timeout_event->closure);
eventer_free(data->timeout_event);
data->timeout_event = NULL;
check->flags &= ~NP_RUNNING;
k.addr_of_check = check;
uuid_copy(k.checkid, check->checkid);
noit_hash_delete(ping_data->in_flight, (const char *)&k,
sizeof(k), free, NULL);
}
}
return EVENTER_READ;
}
int extfs_getinfo(cdico *d, char *devname)
{
struct fsa_ext2_sb *super;
blk_t use_superblock=0;
int use_blocksize=0;
char uuid[512];
ext2_filsys fs;
int origextfstype;
char mntopt[1024];
char label[80];
u32 mask, m;
int count;
int i;
// ---- open partition
if (ext2fs_open(devname, EXT2_FLAG_JOURNAL_DEV_OK | EXT2_FLAG_SOFTSUPP_FEATURES, use_superblock, use_blocksize, unix_io_manager, &fs)!=0)
{ errprintf("ext2fs_open(%s) failed\n", devname);
return -1;
}
super=(struct fsa_ext2_sb *)fs->super;
// --- label
memset(label, 0, sizeof(label));
if (super->s_volume_name[0])
{ memset(label, 0, sizeof(label));
strncpy(label, super->s_volume_name, sizeof(super->s_volume_name));
}
dico_add_string(d, 0, FSYSHEADKEY_FSLABEL, label);
// ---- uuid
/*if ((str=e2p_uuid2str(super->s_uuid))!=NULL)
dico_add_string(d, 0, FSYSHEADKEY_FSUUID, str);*/
memset(uuid, 0, sizeof(uuid));
uuid_unparse_lower((u8*)super->s_uuid, uuid);
dico_add_string(d, 0, FSYSHEADKEY_FSUUID, uuid);
msgprintf(MSG_DEBUG1, "extfs_uuid=[%s]\n", uuid);
// ---- block size
dico_add_u64(d, 0, FSYSHEADKEY_FSEXTBLOCKSIZE, EXT2_BLOCK_SIZE(super));
// ---- filesystem revision (good-old-rev or dynamic)
dico_add_u64(d, 0, FSYSHEADKEY_FSEXTREVISION, super->s_rev_level);
// ---- inode size
if (super->s_rev_level >= EXT2_DYNAMIC_REV)
dico_add_u64(d, 0, FSYSHEADKEY_FSINODESIZE, super->s_inode_size);
else
dico_add_u64(d, 0, FSYSHEADKEY_FSINODESIZE, EXT2_GOOD_OLD_INODE_SIZE); // Good old rev
// ---- extended options
if (super->s_raid_stride > 0)
{ dico_add_u64(d, 0, FSYSHEADKEY_FSEXTEOPTRAIDSTRIDE, super->s_raid_stride);
msgprintf(MSG_DEBUG1, "extfs_raid_stride: %u\n", super->s_raid_stride);
}
if (super->s_raid_stripe_width > 0)
{ dico_add_u64(d, 0, FSYSHEADKEY_FSEXTEOPTRAIDSTRIPEWIDTH, super->s_raid_stripe_width);
msgprintf(MSG_DEBUG1, "extfs_raid_stripe_width: %u\n", super->s_raid_stripe_width);
}
// ---- fsck details: max_mount_count and check_interval
dico_add_u64(d, 0, FSYSHEADKEY_FSEXTFSCKMAXMNTCOUNT, max(super->s_max_mnt_count,0));
dico_add_u64(d, 0, FSYSHEADKEY_FSEXTFSCKCHECKINTERVAL, super->s_checkinterval);
msgprintf(MSG_DEBUG1, "extfs_max_mount_count: %ld\n", (long)max(super->s_max_mnt_count,0));
msgprintf(MSG_DEBUG1, "extfs_check_interval: %ld\n", (long)super->s_checkinterval);
// ---- default mount options
memset(mntopt, 0, sizeof(mntopt));
count=0;
mask=super->s_default_mount_opts;
if (mask & EXT3_DEFM_JMODE)
{ strlcatf(mntopt, sizeof(mntopt), "%s", e2p_mntopt2string(mask & EXT3_DEFM_JMODE));
count++;
}
for (i=0, m=1; i < 32; i++, m<<=1)
{
if (m & EXT3_DEFM_JMODE)
continue;
if (mask & m)
{
if (count++) strlcatf(mntopt, sizeof(mntopt), ",");
strlcatf(mntopt, sizeof(mntopt), "%s", e2p_mntopt2string(m));
}
}
dico_add_string(d, 0, FSYSHEADKEY_FSEXTDEFMNTOPT, mntopt);
msgprintf(MSG_DEBUG1, "default mount options: [%s]\n", mntopt);
// ---- filesystem features
dico_add_u64(d, 0, FSYSHEADKEY_FSEXTFEATURECOMPAT, (u64)super->s_feature_compat);
dico_add_u64(d, 0, FSYSHEADKEY_FSEXTFEATUREINCOMPAT, (u64)super->s_feature_incompat);
dico_add_u64(d, 0, FSYSHEADKEY_FSEXTFEATUREROCOMPAT, (u64)super->s_feature_ro_compat);
origextfstype=extfs_get_fstype_from_compat_flags((u64)super->s_feature_compat, (u64)super->s_feature_incompat, (u64)super->s_feature_ro_compat);
msgprintf(MSG_DEBUG1, "the filesystem type determined by the features is [%s]\n", format_fstype(origextfstype));
// ---- check that fsarchiver is aware of all the filesystem features used on that filesystem
if (extfs_check_compatibility((u64)super->s_feature_compat, (u64)super->s_feature_incompat, (u64)super->s_feature_ro_compat)!=0)
{ errprintf("this filesystem has ext{2,3,4} features which are not supported by this fsarchiver version.\n");
return -1;
}
// ---- minimum fsarchiver version required to restore
dico_add_u64(d, 0, FSYSHEADKEY_MINFSAVERSION, FSA_VERSION_BUILD(0, 6, 4, 0));
ext2fs_close(fs);
return 0;
}
DC_Workunit *DC_createWU(const char *clientName, const char *arguments[],
int subresults, const char *tag)
{
char uuid_str[37];
DC_Workunit *wu;
if (subresults > MAX_SUBRESULTS){
DC_log(LOG_ERR, "DC_createWU: The given subresult number: %d is too high. (max:%d)",
subresults, MAX_SUBRESULTS);
return NULL;
}
if (!clientName)
{
DC_log(LOG_ERR, "DC_createWU: clientName is not supplied");
return NULL;
}
wu = g_new0(DC_Workunit, 1);
wu->argv = g_strdupv((char **)arguments);
for (wu->argc = 0; arguments && arguments[wu->argc]; wu->argc++)
/* Nothing */;
wu->subresults = subresults;
wu->tag = g_strdup(tag);
uuid_generate(wu->uuid);
uuid_unparse_lower(wu->uuid, uuid_str);
wu->uuid_str = g_strdup(uuid_str);
if (tag)
wu->name = g_strdup_printf("%s_%s_%s", project_uuid_str,
uuid_str, tag);
else
wu->name = g_strdup_printf("%s_%s", project_uuid_str, uuid_str);
/* Calculate & create the working directory. The working directory
* has the form:
* <project work dir>/.dcapi-<project uuid>/<hash>/<wu uuid>
* Where <hash> is the first 2 hex digits of the uuid
*/
wu->workdir = get_workdir(wu->uuid, TRUE);
if (!wu->workdir)
{
DC_destroyWU(wu);
return NULL;
}
wu->client_name = /*DC_getClientCfgStr(clientName, "name", FALSE);*/
strdup(clientName);
/*wu->client_path = DC_getClientCfgStr(clientName, "path", FALSE);*/
if (!wu->client_name/* || !wu->client_path*/)
{
DC_log(LOG_ERR, "Failed to create WU. Cannot find client name\n"
"Define client application in the config file:\n"
"[Client-%s]\nname = <client name>\npath = <client path>", clientName);
DC_destroyWU(wu);
return NULL;
}
DC_log(LOG_DEBUG, "client path: %%s, client name: %s from client: %s",
/*wu->client_path,*/ wu->client_name, clientName);
if (!_DC_wu_table)
_DC_wu_table = g_hash_table_new_full(g_str_hash, g_str_equal,
NULL, NULL);
g_hash_table_insert(_DC_wu_table, wu->name, wu);
return wu;
}
void client_read_write(EV_P_ struct ev_io *io, int revents) {
server_ctx_t *srv_ctx = (server_ctx_t *) ev_userdata(loop);
client_ctx_t *cli_ctx = (client_ctx_t *) (((io_with_cctx_t*) io)->ctx);
if (revents & EV_READ) {
while (1) {
if (cli_ctx->r_ctx.read_buff_length == cli_ctx->r_ctx.read_buff_pos) {
char *new_buff = realloc(cli_ctx->r_ctx.read_buff, cli_ctx->r_ctx.read_buff_length + 1024);
if (!new_buff)
break;
cli_ctx->r_ctx.read_buff = new_buff;
cli_ctx->r_ctx.read_buff_length += 1024;
}
ssize_t readed = read(io->fd, &cli_ctx->r_ctx.read_buff[cli_ctx->r_ctx.read_buff_pos], cli_ctx->r_ctx.read_buff_length - cli_ctx->r_ctx.read_buff_pos);
if (readed > 0) {
cli_ctx->r_ctx.read_buff_pos += readed;
for (; cli_ctx->r_ctx.parser_pos < cli_ctx->r_ctx.read_buff_pos - 1; cli_ctx->r_ctx.parser_pos++) {
if ((cli_ctx->r_ctx.read_buff[cli_ctx->r_ctx.parser_pos] == '\r')&&(cli_ctx->r_ctx.read_buff[cli_ctx->r_ctx.parser_pos + 1] == '\n')) {
if (cli_ctx->r_ctx.parser_pos - cli_ctx->r_ctx.prev_parser_pos > 0)
on_client_message(loop, srv_ctx, cli_ctx, &cli_ctx->r_ctx.read_buff[cli_ctx->r_ctx.prev_parser_pos], cli_ctx->r_ctx.parser_pos - cli_ctx->r_ctx.prev_parser_pos + 2);
cli_ctx->r_ctx.parser_pos++;
cli_ctx->r_ctx.prev_parser_pos = cli_ctx->r_ctx.parser_pos + 1;
}
}
if (cli_ctx->r_ctx.prev_parser_pos >= 1024) {
size_t need_to_free = cli_ctx->r_ctx.prev_parser_pos / 1024 * 1024;
size_t need_to_alloc = cli_ctx->r_ctx.read_buff_length - need_to_free;
char *new_buf = (char *) malloc(need_to_alloc);
if (!new_buf)
break;
memcpy(new_buf, &cli_ctx->r_ctx.read_buff[need_to_free], need_to_alloc);
free(cli_ctx->r_ctx.read_buff);
cli_ctx->r_ctx.read_buff = new_buf;
cli_ctx->r_ctx.prev_parser_pos -= need_to_free;
cli_ctx->r_ctx.parser_pos -= need_to_free;
cli_ctx->r_ctx.read_buff_pos -= need_to_free;
cli_ctx->r_ctx.read_buff_length = need_to_alloc;
}
} else if (readed < 0) {
if (errno == EAGAIN)
break;
if (errno == EINTR)
continue;
return;
} else {
char time_buff[32];
time_t now = time(NULL);
strftime(time_buff, sizeof (time_buff), "%Y-%m-%d %H:%M:%S %Z", localtime(&now));
char *addr = inet_ntoa(cli_ctx->client_addr.sin_addr);
char uuid_buff[37];
uuid_unparse_lower(cli_ctx->uuid, (char *) &uuid_buff);
printf("client closed connection %s:%hu %s at %s\n", addr, cli_ctx->client_addr.sin_port, &uuid_buff, &time_buff);
char *disconnected_client_msg = server_client_disconnected(cli_ctx);
for (ssize_t i = 0; i < srv_ctx->clients_count; i++) {
if (uuid_compare(srv_ctx->clients[i]->uuid, cli_ctx->uuid) != 0) {
send_message(loop, srv_ctx->clients[i]->uuid, disconnected_client_msg, strlen(disconnected_client_msg));
}
}
free(disconnected_client_msg);
close_client(loop, cli_ctx);
return;
}
}
}
if (revents & EV_WRITE) {
write_ctx_t *w_ctx = &cli_ctx->w_ctx;
message_buff_t *buffs = &w_ctx->buffs[0];
while (w_ctx->buffs_count > 0) {
while (buffs[0].data_pos < buffs[0].data_length) {
ssize_t writed = write(io->fd, &buffs[0].data[buffs->data_pos], buffs[0].data_length - buffs[0].data_pos);
if (writed > 0) {
buffs[0].data_pos += writed;
} else {
if (errno == EAGAIN)
break;
if (errno == EINTR)
continue;
break;
}
}
if (buffs[0].data_pos == buffs[0].data_length) {
free(buffs[0].data);
memmove(&buffs[0], &buffs[1], sizeof (message_buff_t) * (w_ctx->buffs_count - 1));
w_ctx->buffs_count--;
} else {
break;
}
}
if (w_ctx->buffs_count == 0) {
ev_io *io = &cli_ctx->io.io;
ev_io_stop(loop, io);
ev_io_set(io, io->fd, EV_READ);
ev_io_start(loop, io);
cli_ctx->writing = 0;
}
}
}
std::string string()
{
char out[40];
uuid_unparse_lower(m_uuid, out);
return out;
}
int xfs_getinfo(cdico *d, char *devname)
{
struct xfs_sb sb;
char uuid[512];
u64 xfsver;
u32 temp32;
int ret=0;
int fd;
int res;
u64 sb_features_compat=0;
u64 sb_features_ro_compat=0;
u64 sb_features_incompat=0;
u64 sb_features_log_incompat=0;
if ((fd=open64(devname, O_RDONLY|O_LARGEFILE))<0)
{ ret=-1;
goto xfs_read_sb_return;
}
res=read(fd, &sb, sizeof(sb));
if (res!=sizeof(sb))
{ ret=-1;
goto xfs_read_sb_close;
}
// ---- check it's an XFS file system
if (be32_to_cpu(sb.sb_magicnum) != XFS_SB_MAGIC)
{ ret=-1;
msgprintf(3, "sb.sb_magicnum!=XFS_SB_MAGIC\n");
goto xfs_read_sb_close;
}
// ---- check XFS filesystem version
xfsver=be16_to_cpu(sb.sb_versionnum) & XFS_SB_VERSION_NUMBITS;
switch (xfsver)
{
case XFS_SB_VERSION_4:
case XFS_SB_VERSION_5:
msgprintf(MSG_DEBUG1, "Detected XFS filesystem version %d\n", (int)xfsver);
dico_add_u64(d, 0, FSYSHEADKEY_FSXFSVERSION, xfsver);
break;
default:
ret=-1;
msgprintf(MSG_STACK, "Invalid XFS filesystem version: version=[%d]\n", (int)xfsver);
goto xfs_read_sb_close;
break;
}
// ---- label
msgprintf(MSG_DEBUG1, "xfs_label=[%s]\n", sb.sb_fname);
dico_add_string(d, 0, FSYSHEADKEY_FSLABEL, (char*)sb.sb_fname);
// ---- uuid
/*if ((str=e2p_uuid2str(&sb.sb_uuid))!=NULL)
dico_add_string(d, 0, FSYSHEADKEY_FSUUID, str);*/
memset(uuid, 0, sizeof(uuid));
uuid_unparse_lower((u8*)&sb.sb_uuid, uuid);
dico_add_string(d, 0, FSYSHEADKEY_FSUUID, uuid);
msgprintf(MSG_DEBUG1, "xfs_uuid=[%s]\n", uuid);
// ---- block size
temp32=be32_to_cpu(sb.sb_blocksize);
if ((temp32%512!=0) || (temp32<512) || (temp32>65536))
{ ret=-1;
msgprintf(3, "xfs_blksize=[%ld] is an invalid xfs block size\n", (long)temp32);
goto xfs_read_sb_close;
}
dico_add_u64(d, 0, FSYSHEADKEY_FSXFSBLOCKSIZE, temp32);
msgprintf(MSG_DEBUG1, "xfs_blksize=[%ld]\n", (long)temp32);
// ---- get filesystem features (will all be set to 0 if this is an XFSv4)
if (xfsver == XFS_SB_VERSION_5)
{
sb_features_compat=be32_to_cpu(sb.sb_features_compat);
sb_features_ro_compat=be32_to_cpu(sb.sb_features_ro_compat);
sb_features_incompat=be32_to_cpu(sb.sb_features_incompat);
sb_features_log_incompat=be32_to_cpu(sb.sb_features_log_incompat);
}
// ---- check fsarchiver is aware of all the filesystem features used on that filesystem
if (xfs_check_compatibility(sb_features_compat, sb_features_ro_compat, sb_features_incompat, sb_features_log_incompat)!=0)
return -1;
// ---- store features in the archive metadata
dico_add_u64(d, 0, FSYSHEADKEY_FSXFSFEATURECOMPAT, (u64)sb_features_compat);
dico_add_u64(d, 0, FSYSHEADKEY_FSXFSFEATUREROCOMPAT, (u64)sb_features_ro_compat);
dico_add_u64(d, 0, FSYSHEADKEY_FSXFSFEATUREINCOMPAT, (u64)sb_features_incompat);
dico_add_u64(d, 0, FSYSHEADKEY_FSXFSFEATURELOGINCOMPAT, (u64)sb_features_log_incompat);
// ---- minimum fsarchiver version required to restore
dico_add_u64(d, 0, FSYSHEADKEY_MINFSAVERSION, FSA_VERSION_BUILD(0, 6, 20, 0));
xfs_read_sb_close:
close(fd);
xfs_read_sb_return:
return ret;
}
static int
noit_console_check(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state, void *closure) {
int cnt;
noit_conf_t_userdata_t *info;
char xpath[1024], newuuid_str[37];
char *uuid_conf, *wanted;
uuid_t checkid;
xmlXPathContextPtr xpath_ctxt = NULL;
xmlXPathObjectPtr pobj = NULL;
xmlNodePtr node = NULL;
noit_boolean creating_new = noit_false;
if(closure) {
char *fake_argv[1] = { ".." };
noit_console_state_pop(ncct, 0, argv, NULL, NULL);
noit_console_config_cd(ncct, 1, fake_argv, NULL, NULL);
}
noit_conf_xml_xpath(NULL, &xpath_ctxt);
if(argc < 1) {
nc_printf(ncct, "requires at least one argument\n");
return -1;
}
if(argc % 2 == 0) {
nc_printf(ncct, "wrong number of arguments\n");
return -1;
}
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
wanted = strcmp(argv[0], "new") ? argv[0] : NULL;
if(info && !wanted) {
/* We are creating a new node */
uuid_t out;
creating_new = noit_true;
if(strncmp(info->path, "/checks/", strlen("/checks/")) &&
strcmp(info->path, "/checks")) {
nc_printf(ncct, "New checks must be under /checks/\n");
return -1;
}
if(noit_conf_mkcheck_under(info->path, argc - 1, argv + 1, out)) {
nc_printf(ncct, "Error creating new check\n");
return -1;
}
newuuid_str[0] = '\0';
uuid_unparse_lower(out, newuuid_str);
wanted = newuuid_str;
}
/* We many not be in conf-t mode -- that's fine */
if(noit_console_mkcheck_xpath(xpath, sizeof(xpath), info, wanted)) {
nc_printf(ncct, "could not find check '%s'\n", wanted);
return -1;
}
pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt);
if(!pobj || pobj->type != XPATH_NODESET ||
xmlXPathNodeSetIsEmpty(pobj->nodesetval)) {
nc_printf(ncct, "no checks found for '%s'\n", wanted);
goto out;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
if(info && cnt != 1) {
nc_printf(ncct, "Ambiguous check specified\n");
goto out;
}
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, 0);
uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid");
if(!uuid_conf || uuid_parse(uuid_conf, checkid)) {
nc_printf(ncct, "%s has invalid or missing UUID!\n",
(char *)xmlGetNodePath(node) + strlen("/noit"));
goto out;
}
if(argc > 1 && !creating_new)
if(noit_config_check_update_attrs(node, argc - 1, argv + 1))
nc_printf(ncct, "Partially successful, error setting some attributes\n");
if(info) {
if(info->path) free(info->path);
info->path = strdup((char *)xmlGetNodePath(node) + strlen("/noit"));
uuid_copy(info->current_check, checkid);
if(argc > 1) refresh_subchecks(ncct, info);
if(state) {
noit_console_state_push_state(ncct, state);
noit_console_state_init(ncct);
}
goto out;
}
out:
if(pobj) xmlXPathFreeObject(pobj);
return 0;
}
int
slot_msg(struct sbd_context *st, const char *name, const char *cmd)
{
struct sector_header_s *s_header = NULL;
struct sector_mbox_s *s_mbox = NULL;
int mbox;
int rc = 0;
char uuid[37];
if (!name || !cmd) {
cl_log(LOG_ERR, "slot_msg(): No recipient / cmd specified.\n");
rc = -1; goto out;
}
s_header = header_get(st);
if (!s_header) {
rc = -1; goto out;
}
if (strcmp(name, "LOCAL") == 0) {
name = local_uname;
}
if (s_header->minor_version > 0) {
uuid_unparse_lower(s_header->uuid, uuid);
cl_log(LOG_INFO, "Device UUID: %s", uuid);
}
mbox = slot_lookup(st, s_header, name);
if (mbox < 0) {
cl_log(LOG_ERR, "slot_msg(): No slot found for %s.", name);
rc = -1; goto out;
}
s_mbox = sector_alloc();
s_mbox->cmd = cmd2char(cmd);
if (s_mbox->cmd < 0) {
cl_log(LOG_ERR, "slot_msg(): Invalid command %s.", cmd);
rc = -1; goto out;
}
strncpy(s_mbox->from, local_uname, sizeof(s_mbox->from)-1);
cl_log(LOG_INFO, "Writing %s to node slot %s",
cmd, name);
if (mbox_write_verify(st, mbox, s_mbox) < -1) {
rc = -1; goto out;
}
if (strcasecmp(cmd, "exit") != 0) {
cl_log(LOG_INFO, "Messaging delay: %d",
(int)timeout_msgwait);
sleep(timeout_msgwait);
}
cl_log(LOG_INFO, "%s successfully delivered to %s",
cmd, name);
out: free(s_mbox);
free(s_header);
return rc;
}
char *
SmsGenerateClientID(SmsConn smsConn)
{
#if defined(HAVE_UUID_CREATE)
char *id;
char **temp;
uuid_t uuid;
uint32_t status;
uuid_create(&uuid, &status);
uuid_to_string(&uuid, &temp, &status);
if ((id = malloc (strlen (temp) + 2)) != NULL)
{
id[0] = '2';
strcpy (id+1, temp);
}
free(temp);
return id;
#elif defined(HAVE_LIBUUID)
char *id;
char temp[256];
uuid_t uuid;
uuid_generate(uuid);
temp[0] = '2';
temp[1] = '\0';
uuid_unparse_lower(uuid, &temp[1]);
if ((id = malloc (strlen (temp) + 1)) != NULL)
strcpy (id, temp);
return id;
#else
#if defined(TCPCONN) || defined(STREAMSCONN)
static const char hex[] = "0123456789abcdef";
char hostname[256];
char address[64], *addr_ptr = address;
char temp[256];
char *id;
static int sequence = 0;
if (gethostname (hostname, sizeof (hostname)))
return (NULL);
{
char* inet_addr;
char temp[4], *ptr1, *ptr2;
unsigned char decimal[4];
int i, len;
struct in_addr *haddr = NULL;
#if defined(IPv6) && defined(AF_INET6)
struct addrinfo *ai, *first_ai;
if (getaddrinfo(hostname,NULL,NULL,&ai) != 0)
return NULL;
for (first_ai = ai; ai != NULL; ai = ai->ai_next) {
if ( (ai->ai_family == AF_INET) || (ai->ai_family == AF_INET6) )
break;
}
if (ai == NULL) {
freeaddrinfo(first_ai);
return NULL;
}
if (ai->ai_family == AF_INET6) {
unsigned char *cp = (unsigned char *) &((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr.s6_addr;
*addr_ptr++ = '6'; /* IPv6 address code */
for (i = 0 ; i < 16 ; i++) {
*addr_ptr++ = hex[cp[i] >> 4];
*addr_ptr++ = hex[cp[i] & 0x0f];
}
*addr_ptr++ = '\0';
} else { /* Fall through to IPv4 address handling */
static void external_log_results(noit_module_t *self, noit_check_t *check) {
external_data_t *data;
struct check_info *ci;
stats_t current;
struct timeval duration;
noit_check_stats_clear(¤t);
data = noit_module_get_userdata(self);
ci = (struct check_info *)check->closure;
noitL(data->nldeb, "external(%s) (timeout: %d, exit: %x)\n",
check->target, ci->timedout, ci->exit_code);
gettimeofday(¤t.whence, NULL);
sub_timeval(current.whence, check->last_fire_time, &duration);
current.duration = duration.tv_sec * 1000 + duration.tv_usec / 1000;
if(ci->timedout) {
current.available = NP_UNAVAILABLE;
current.state = NP_BAD;
}
else if(WEXITSTATUS(ci->exit_code) == 3) {
current.available = NP_UNKNOWN;
current.state = NP_UNKNOWN;
}
else {
current.available = NP_AVAILABLE;
current.state = (WEXITSTATUS(ci->exit_code) == 0) ? NP_GOOD : NP_BAD;
}
/* Hack the output into metrics */
if(ci->output && ci->matcher) {
int rc, len, startoffset = 0;
int ovector[30];
len = strlen(ci->output);
noitL(data->nldeb, "going to match output at %d/%d\n", startoffset, len);
while((rc = pcre_exec(ci->matcher, NULL, ci->output, len, startoffset, 0,
ovector, sizeof(ovector)/sizeof(*ovector))) > 0) {
char metric[128];
char value[128];
startoffset = ovector[1];
noitL(data->nldeb, "matched at offset %d\n", rc);
if(pcre_copy_named_substring(ci->matcher, ci->output, ovector, rc,
"key", metric, sizeof(metric)) > 0 &&
pcre_copy_named_substring(ci->matcher, ci->output, ovector, rc,
"value", value, sizeof(value)) > 0) {
/* We're able to extract something... */
noit_stats_set_metric(¤t, metric, METRIC_GUESS, value);
}
noitL(data->nldeb, "going to match output at %d/%d\n", startoffset, len);
}
noitL(data->nldeb, "match failed.... %d\n", rc);
}
current.status = ci->output;
noit_check_set_stats(self, check, ¤t);
/* If we didn't exit normally, or we core, or we have stderr to report...
* provide a full report.
*/
if((WTERMSIG(ci->exit_code) != SIGQUIT && WTERMSIG(ci->exit_code) != 0) ||
WCOREDUMP(ci->exit_code) ||
(ci->error && *ci->error)) {
char uuid_str[37];
uuid_unparse_lower(check->checkid, uuid_str);
noitL(data->nlerr, "external/%s: (sig:%d%s) [%s]\n", uuid_str,
WTERMSIG(ci->exit_code), WCOREDUMP(ci->exit_code)?", cored":"",
ci->error ? ci->error : "");
}
}
static int nilfs_cleaner_open_queue(struct nilfs_cleaner *cleaner)
{
char nambuf[NAME_MAX - 4];
char uuidbuf[36 + 1];
struct mq_attr attr = {
.mq_maxmsg = 3,
.mq_msgsize = sizeof(struct nilfs_cleaner_response)
};
int ret;
uuid_generate(cleaner->client_uuid);
uuid_unparse_lower(cleaner->client_uuid, uuidbuf);
/* receive queue */
ret = snprintf(nambuf, sizeof(nambuf), "/nilfs-cleanerq-%s", uuidbuf);
if (ret < 0)
goto error;
assert(ret < sizeof(nambuf));
cleaner->recvq_name = strdup(nambuf);
if (!cleaner->recvq_name)
goto error;
cleaner->recvq = mq_open(nambuf, O_RDONLY | O_CREAT | O_EXCL, 0600,
&attr);
if (cleaner->recvq < 0) {
nilfs_cleaner_logger(LOG_ERR,
_("Error: cannot create receive queue: "
"%s."),
strerror(errno));
free(cleaner->recvq_name);
goto abort;
}
/* send queue */
if (cleaner->dev_ino == 0) {
ret = snprintf(nambuf, sizeof(nambuf),
"/nilfs-cleanerq-%llu",
(unsigned long long)cleaner->dev_id);
} else {
ret = snprintf(nambuf, sizeof(nambuf),
"/nilfs-cleanerq-%llu-%llu",
(unsigned long long)cleaner->dev_id,
(unsigned long long)cleaner->dev_ino);
}
if (ret < 0)
goto error;
assert(ret < sizeof(nambuf));
cleaner->sendq = mq_open(nambuf, O_WRONLY);
if (cleaner->sendq < 0) {
if (errno == ENOENT) {
nilfs_cleaner_logger(LOG_NOTICE,
_("No cleaner found on %s."),
cleaner->device);
} else {
nilfs_cleaner_logger(LOG_ERR,
_("Error: cannot open cleaner on "
"%s: %s."),
cleaner->device, strerror(errno));
}
goto abort;
}
return 0;
error:
nilfs_cleaner_logger(LOG_ERR,
_("Error: fatal error during queue setting: %s."),
strerror(errno));
abort:
if (cleaner->recvq >= 0) {
mq_close(cleaner->recvq);
cleaner->recvq = -1;
mq_unlink(cleaner->recvq_name);
free(cleaner->recvq_name);
}
return -1;
}
static void nilfs_cleaner_close_queue(struct nilfs_cleaner *cleaner)
{
if (cleaner->recvq >= 0) {
mq_close(cleaner->recvq);
mq_unlink(cleaner->recvq_name);
free(cleaner->recvq_name);
cleaner->recvq = -1;
cleaner->recvq_name = NULL;
}
if (cleaner->sendq >= 0) {
mq_close(cleaner->sendq);
cleaner->sendq = -1;
}
}
struct nilfs_cleaner *nilfs_cleaner_launch(const char *device,
const char *mntdir,
unsigned long protperiod)
{
struct nilfs_cleaner *cleaner;
cleaner = malloc(sizeof(*cleaner));
if (!cleaner)
goto error;
memset(cleaner, 0, sizeof(*cleaner));
cleaner->sendq = -1;
cleaner->recvq = -1;
cleaner->device = strdup(device);
cleaner->mountdir = strdup(mntdir);
if (!cleaner->device || !cleaner->mountdir)
goto error;
if (nilfs_launch_cleanerd(device, mntdir, protperiod,
&cleaner->cleanerd_pid) < 0)
goto abort;
if (nilfs_cleaner_get_device_id(cleaner) < 0)
goto abort;
return cleaner; /* cleanerd started */
error:
nilfs_cleaner_logger(LOG_ERR, _("Error: %s"), strerror(errno));
abort:
if (cleaner) {
free(cleaner->device); /* free(NULL) is just ignored */
free(cleaner->mountdir);
free(cleaner);
}
return NULL;
}
struct nilfs_cleaner *nilfs_cleaner_open(const char *device,
const char *mntdir, int oflag)
{
struct nilfs_cleaner *cleaner;
cleaner = malloc(sizeof(*cleaner));
if (!cleaner)
goto error;
memset(cleaner, 0, sizeof(*cleaner));
cleaner->sendq = -1;
cleaner->recvq = -1;
if (nilfs_cleaner_find_fs(cleaner, device, mntdir) < 0)
goto abort;
if (nilfs_cleaner_get_device_id(cleaner) < 0)
goto abort;
if ((oflag & NILFS_CLEANER_OPEN_GCPID) && cleaner->cleanerd_pid == 0) {
nilfs_cleaner_logger(LOG_ERR,
_("Error: cannot get cleanerd pid"));
goto abort;
}
if ((oflag & NILFS_CLEANER_OPEN_QUEUE) &&
nilfs_cleaner_open_queue(cleaner) < 0)
goto abort;
return cleaner;
error:
nilfs_cleaner_logger(LOG_ERR, _("Error: %s"), strerror(errno));
abort:
if (cleaner) {
free(cleaner->device); /* free(NULL) is just ignored */
free(cleaner->mountdir);
free(cleaner);
}
return NULL;
}
int nilfs_cleaner_ping(struct nilfs_cleaner *cleaner)
{
return process_is_alive(cleaner->cleanerd_pid);
}
pid_t nilfs_cleaner_pid(const struct nilfs_cleaner *cleaner)
{
return cleaner->cleanerd_pid;
}
const char *nilfs_cleaner_device(const struct nilfs_cleaner *cleaner)
{
return cleaner->device;
}
void nilfs_cleaner_close(struct nilfs_cleaner *cleaner)
{
nilfs_cleaner_close_queue(cleaner);
free(cleaner->device);
free(cleaner->mountdir);
free(cleaner);
}
int
fq_client_creds(fq_client conn, const char *host, unsigned short port,
const char *sender, const char *pass) {
fq_conn_s *conn_s;
conn_s = conn;
/* make the sockets as disconnected */
conn_s->cmd_fd = conn_s->data_fd = -1;
/* parse the user info */
conn_s->user = strdup(sender);
conn_s->queue = strchr(conn_s->user, '/');
if(conn_s->queue) *conn_s->queue++ = '\0';
if(!conn_s->queue) {
uuid_t out;
char qname[39];
uuid_generate(out);
qname[0] = 'q'; qname[1] = '-';
uuid_unparse_lower(out, qname+2);
conn_s->queue = qname;
}
conn_s->queue = strdup(conn_s->queue);
conn_s->pass = strdup(pass);
/* determine our endpoint */
conn_s->remote.sin_family = AF_INET;
conn_s->remote.sin_port = htons(port);
if(inet_pton(AF_INET, host, &conn_s->remote.sin_addr) != 0) {
#ifdef HAVE_GETHOSTBYNAME_R
struct hostent hostbuf, *hp;
struct in_addr **addr_list;
int buflen = 1024, herr, hres;
char *buf;
if((buf = malloc(buflen)) == NULL) {
CONNERR(conn_s, "out of memory");
return -1;
}
while((hres = gethostbyname_r(host, &hostbuf,
buf, buflen, &hp, &herr)) == ERANGE) {
buflen *= 2;
if((buf = realloc(buf, buflen)) == NULL) {
CONNERR(conn_s, "out of memory");
return -1;
}
}
if(!hp) {
CONNERR(conn_s, "host lookup failed");
return -1;
}
addr_list = (struct in_addr **)hp->h_addr_list;
if(*addr_list == 0) {
CONNERR(conn_s, "no address for host");
return -1;
}
memcpy(&conn_s->remote.sin_addr, *addr_list, sizeof(struct in_addr));
free(buf);
#else
struct hostent *hp;
struct in_addr **addr_list;
hp = gethostbyname(host);
if(!hp) {
CONNERR(conn_s, "host lookup failed");
return -1;
}
addr_list = (struct in_addr **)hp->h_addr_list;
if(*addr_list == 0) {
CONNERR(conn_s, "no address for host");
return -1;
}
memcpy(&conn_s->remote.sin_addr, *addr_list, sizeof(struct in_addr));
#endif
}
conn_s->cmdqhead = malloc(sizeof(ck_fifo_mpmc_entry_t));
ck_fifo_mpmc_init(&conn_s->cmdq, conn_s->cmdqhead);
conn_s->qhead = malloc(sizeof(ck_fifo_mpmc_entry_t));
ck_fifo_mpmc_init(&conn_s->q, conn_s->qhead);
conn_s->backqhead = malloc(sizeof(ck_fifo_mpmc_entry_t));
ck_fifo_mpmc_init(&conn_s->backq, conn_s->backqhead);
return 0;
}
static void
log_histo(struct histogram_config *conf,
noit_check_t *check, u_int64_t whence_s,
const char *metric_name, histogram_t *h,
mtev_boolean live_feed) {
mtev_boolean extended_id = mtev_false;
char uuid_str[256*3+37];
const char *v;
char *hist_serial = NULL;
char *hist_encode = NULL;
struct timeval whence;
ssize_t est, enc_est;
whence.tv_sec = whence_s;
whence.tv_usec = 0;
if(!conf->histogram) return;
SETUP_LOG(metrics, );
if(metrics_log) {
v = mtev_log_stream_get_property(metrics_log, "extended_id");
if(v && !strcmp(v, "on")) extended_id = mtev_true;
}
uuid_str[0] = '\0';
if(extended_id) {
strlcat(uuid_str, check->target, sizeof(uuid_str)-37);
strlcat(uuid_str, "`", sizeof(uuid_str)-37);
strlcat(uuid_str, check->module, sizeof(uuid_str)-37);
strlcat(uuid_str, "`", sizeof(uuid_str)-37);
strlcat(uuid_str, check->name, sizeof(uuid_str)-37);
strlcat(uuid_str, "`", sizeof(uuid_str)-37);
}
uuid_unparse_lower(check->checkid, uuid_str + strlen(uuid_str));
#define SECPART(a) ((unsigned long)(a)->tv_sec)
#define MSECPART(a) ((unsigned long)((a)->tv_usec / 1000))
est = hist_serialize_estimate(h);
hist_serial = malloc(est);
if(!hist_serial) {
mtevL(noit_error, "malloc(%d) failed\n", (int)est);
goto cleanup;
}
enc_est = ((est + 2)/3)*4;
hist_encode = malloc(enc_est);
if(!hist_encode) {
mtevL(noit_error, "malloc(%d) failed\n", (int)enc_est);
goto cleanup;
}
if(hist_serialize(h, hist_serial, est) != est) {
mtevL(noit_error, "histogram serialization failure\n");
goto cleanup;
}
enc_est = mtev_b64_encode((unsigned char *)hist_serial, est,
hist_encode, enc_est);
if(enc_est < 0) {
mtevL(noit_error, "base64 histogram encoding failure\n");
goto cleanup;
}
if(live_feed && check->feeds) {
mtev_skiplist_node *curr, *next;
curr = next = mtev_skiplist_getlist(check->feeds);
while(curr) {
const char *feed_name = (char *)curr->data;
mtev_log_stream_t ls = mtev_log_stream_find(feed_name);
mtev_skiplist_next(check->feeds, &next);
if(!ls ||
mtev_log(ls, &whence, __FILE__, __LINE__,
"H1\t%lu.%03lu\t%s\t%s\t%.*s\n",
SECPART(&whence), MSECPART(&whence),
uuid_str, metric_name, (int)enc_est, hist_encode))
noit_check_transient_remove_feed(check, feed_name);
curr = next;
}
}
if(!live_feed) {
SETUP_LOG(metrics, goto cleanup);
mtev_log(metrics_log, &whence, __FILE__, __LINE__,
"H1\t%lu.%03lu\t%s\t%s\t%.*s\n",
SECPART(&whence), MSECPART(&whence),
uuid_str, metric_name, (int)enc_est, hist_encode);
}
int
stratcon_request_dispatcher(noit_http_session_ctx *ctx) {
const char *key, *value;
realtime_context *rc = ctx->dispatcher_closure;
int klen;
noit_hash_iter iter = NOIT_HASH_ITER_ZERO;
noit_http_request *req = &ctx->req;
if(rc->setup == RC_INITIAL) {
eventer_t completion;
struct realtime_tracker *node;
char c[1024];
int num_interests;
num_interests = stratcon_realtime_uri_parse(rc, ctx->req.uri_str);
if(num_interests == 0) {
noit_http_response_status_set(ctx, 404, "OK");
noit_http_response_option_set(ctx, NOIT_HTTP_CLOSE);
noit_http_response_end(ctx);
return 0;
}
noitL(noit_error, "http: %s %s %s\n",
req->method_str, req->uri_str, req->protocol_str);
while(noit_hash_next_str(&req->headers, &iter, &key, &klen, &value)) {
noitL(noit_error, "http: [%s: %s]\n", key, value);
}
noit_http_response_status_set(ctx, 200, "OK");
noit_http_response_option_set(ctx, NOIT_HTTP_CHUNKED);
/*noit_http_response_option_set(ctx, NOIT_HTTP_GZIP);*/
/*noit_http_response_option_set(ctx, NOIT_HTTP_DEFLATE);*/
noit_http_response_header_set(ctx, "Content-Type", "text/html");
snprintf(c, sizeof(c),
"<html><head><script>document.domain='%s';</script></head><body>\n",
rc->document_domain);
noit_http_response_append(ctx, c, strlen(c));
/* this dumb crap is to make some browsers happy (Safari) */
memset(c, ' ', sizeof(c));
noit_http_response_append(ctx, c, sizeof(c));
noit_http_response_flush(ctx, noit_false);
rc->setup = RC_REQ_RECV;
/* Each interest references the ctx */
for(node = rc->checklist; node; node = node->next) {
char uuid_str[UUID_STR_LEN+1];
noit_atomic_inc32(&ctx->ref_cnt);
uuid_unparse_lower(node->checkid, uuid_str);
noitL(noit_error, "Resolving uuid: %s\n", uuid_str);
}
completion = eventer_alloc();
completion->mask = EVENTER_TIMER;
completion->callback = stratcon_realtime_http_postresolve;
completion->closure = ctx;
gettimeofday(&completion->whence, NULL);
stratcon_datastore_push(DS_OP_FIND_COMPLETE, NULL, NULL,
rc->checklist, completion);
}
return EVENTER_EXCEPTION;
}
int
stratcon_realtime_recv_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
static u_int32_t livestream_cmd = 0;
noit_connection_ctx_t *nctx = closure;
realtime_recv_ctx_t *ctx = nctx->consumer_ctx;
int len;
u_int32_t nint;
char uuid_str[37];
if(!livestream_cmd) livestream_cmd = htonl(NOIT_LIVESTREAM_DATA_FEED);
if(mask & EVENTER_EXCEPTION || nctx->wants_shutdown) {
socket_error:
ctx->state = REALTIME_HTTP_WANT_INITIATE;
ctx->count = 0;
ctx->bytes_read = 0;
ctx->bytes_written = 0;
ctx->bytes_expected = 0;
if(ctx->buffer) free(ctx->buffer);
ctx->buffer = NULL;
noit_connection_ctx_dealloc(nctx);
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &mask, e);
return 0;
}
#define full_nb_write(data, wlen) do { \
if(!ctx->bytes_expected) { \
ctx->bytes_written = 0; \
ctx->bytes_expected = wlen; \
} \
while(ctx->bytes_written < ctx->bytes_expected) { \
while(-1 == (len = e->opset->write(e->fd, ((char *)data) + ctx->bytes_written, \
ctx->bytes_expected - ctx->bytes_written, \
&mask, e)) && errno == EINTR); \
if(len < 0) { \
if(errno == EAGAIN) return mask | EVENTER_EXCEPTION; \
goto socket_error; \
} \
ctx->bytes_written += len; \
} \
if(ctx->bytes_written != ctx->bytes_expected) { \
noitL(noit_error, "short write on initiating stream [%d != %d].\n", \
ctx->bytes_written, ctx->bytes_expected); \
goto socket_error; \
} \
ctx->bytes_expected = 0; \
} while(0)
noit_connection_update_timeout(nctx);
while(1) {
u_int32_t net_body_len;
switch(ctx->state) {
case REALTIME_HTTP_WANT_INITIATE:
full_nb_write(&livestream_cmd, sizeof(livestream_cmd));
ctx->state = REALTIME_HTTP_WANT_SEND_INTERVAL;
case REALTIME_HTTP_WANT_SEND_INTERVAL:
nint = htonl(ctx->rt->interval);
full_nb_write(&nint, sizeof(nint));
ctx->state = REALTIME_HTTP_WANT_SEND_UUID;
case REALTIME_HTTP_WANT_SEND_UUID:
uuid_unparse_lower(ctx->rt->checkid, uuid_str);
full_nb_write(uuid_str, 36);
ctx->state = REALTIME_HTTP_WANT_HEADER;
case REALTIME_HTTP_WANT_HEADER:
FULLREAD(e, ctx, sizeof(u_int32_t));
memcpy(&net_body_len, ctx->buffer, sizeof(u_int32_t));
ctx->body_len = ntohl(net_body_len);
free(ctx->buffer); ctx->buffer = NULL;
ctx->state = REALTIME_HTTP_WANT_BODY;
break;
case REALTIME_HTTP_WANT_BODY:
FULLREAD(e, ctx, ctx->body_len);
if(stratcon_line_to_javascript(ctx->ctx, ctx->buffer, ctx->hack_inc_id++)) goto socket_error;
free(ctx->buffer); ctx->buffer = NULL;
ctx->state = REALTIME_HTTP_WANT_HEADER;
break;
}
}
}
