END_TEST START_TEST(test_giant_alarm) { char *msg="This is a really large message that exceeds the 256 or " "so bytes allocated for messages to see what happens when a " "message is too big. Hopefully it's fine. " "It turns out that 256 bytes or whatever the current value is ends " "up being quite a bit of bytes. I suppose that makes sense if " "I do a bit of math, but I'm too lazy to do anything other than assert."; fail_unless(strlen(msg) > ALARM_MSG_MAXLEN, "Message string was too short to blow up."); fail_unless(add_alarm(alarmqueue, "bigass", msg), "Failed to alarm."); alarm_t in_alarm = get_alarm(alarmqueue); fail_unless(in_alarm.open, "Didn't receive a large alarm."); fail_unless(strlen(in_alarm.msg) == ALARM_MSG_MAXLEN, "Alarm message is too long."); fail_unless(strcmp("bigass", in_alarm.name) == 0, "Alarm name didn't match."); fail_unless(strncmp(msg, in_alarm.msg, ALARM_MSG_MAXLEN) == 0, "Alarm message didn't match."); }
static int alarmqueue_handler(xmpp_conn_t * const conn, void * const userdata) { conflate_handle_t *handle = (conflate_handle_t*) userdata; alarm_t alarm; const char* myjid = xmpp_conn_get_bound_jid(conn); char id[262]; char open[2] = { 0, 0 }; char amsg[256]; char body[1500]; char num[255]; while (handle->alarms->size > 0) { alarm = get_alarm(handle->alarms); open[0] = alarm.open ? '1' : '2'; snprintf(amsg, sizeof(amsg), "%s", alarm.msg); /* if we got a legitimate alarm, send off alert */ if(alarm.open == 1) { snprintf(id, sizeof(id), "_alarm%d", alarm.num); //handler_add_id(conn, alarm_response_handler, id, handle); //handler_add_timed(conn, alarm_missing_handler, 120000, handle); xmpp_stanza_t* msg = xmpp_stanza_new(handle->ctx); assert(msg); xmpp_stanza_set_name(msg, "message"); //xmpp_stanza_set_type(iq, "set"); xmpp_stanza_set_id(msg, id); //xmpp_stanza_set_attribute(iq, "to", xmpp_stanza_get_attribute(stanza, "from")); /* TODO: This needs to have a config on where to report to */ xmpp_stanza_set_attribute(msg, "to", "*****@*****.**"); xmpp_stanza_set_attribute(msg, "from", myjid); xmpp_stanza_t* mbody = xmpp_stanza_new(handle->ctx); assert(mbody); xmpp_stanza_set_name(mbody, "body"); snprintf(body, sizeof(body), "Alert\n%s", amsg); snprintf(num, sizeof(num), "%d", alarm.num); xmpp_stanza_set_text(mbody, body); add_and_release(msg, mbody); xmpp_stanza_t* alert = xmpp_stanza_new(handle->ctx); assert(alert); xmpp_stanza_set_name(alert, "alert"); xmpp_stanza_set_attribute(alert, "xmlns", "http://northscale.net/protocol/alerts"); xmpp_stanza_set_attribute(alert, "open", open); xmpp_stanza_set_attribute(alert, "msg", amsg); xmpp_stanza_set_attribute(alert, "num", num); xmpp_stanza_set_attribute(alert, "name", alarm.name); add_and_release(msg, alert); xmpp_send(conn, msg); xmpp_stanza_release(msg); } } return 1; }
END_TEST START_TEST(test_giant_name) { const char *name = "this name should exceed the max length"; fail_unless(strlen(name) > ALARM_NAME_MAXLEN, "Name wasn't too big enough."); fail_unless(add_alarm(alarmqueue, name, "some message"), "Failed to alarm."); alarm_t in_alarm = get_alarm(alarmqueue); fail_unless(in_alarm.open, "Didn't receive an alarm."); fail_unless(strlen(in_alarm.name) == ALARM_NAME_MAXLEN, "Alarm name is too long."); fail_unless(strncmp(name, in_alarm.name, ALARM_NAME_MAXLEN) == 0, "Alarm name didn't match."); fail_unless(strcmp("some message", in_alarm.msg) == 0, "Alarm message didn't match."); }
/* * This code relies on *poriginal being aligned and all increments done by the * blocks only changing the buffer pointer in a way that does not break alignment. */ static void getOptions(DBADDR *paddr, char **poriginal, long *options, void *pflin) { db_field_log *pfl= (db_field_log *)pflin; struct rset *prset; short field_type; dbCommon *pcommon; char *pbuffer = *poriginal; if (!pfl || pfl->type == dbfl_type_rec) field_type = paddr->field_type; else field_type = pfl->field_type; prset=dbGetRset(paddr); /* Process options */ pcommon = paddr->precord; if( (*options) & DBR_STATUS ) { unsigned short *pushort = (unsigned short *)pbuffer; if (!pfl || pfl->type == dbfl_type_rec) { *pushort++ = pcommon->stat; *pushort++ = pcommon->sevr; } else { *pushort++ = pfl->stat; *pushort++ = pfl->sevr; } *pushort++ = pcommon->acks; *pushort++ = pcommon->ackt; pbuffer = (char *)pushort; } if( (*options) & DBR_UNITS ) { memset(pbuffer,'\0',dbr_units_size); if( prset && prset->get_units ){ (*prset->get_units)(paddr, pbuffer); pbuffer[DB_UNITS_SIZE-1] = '\0'; } else { *options ^= DBR_UNITS; /*Turn off DBR_UNITS*/ } pbuffer += dbr_units_size; } if( (*options) & DBR_PRECISION ) { memset(pbuffer, '\0', dbr_precision_size); if((field_type==DBF_FLOAT || field_type==DBF_DOUBLE) && prset && prset->get_precision ){ (*prset->get_precision)(paddr,pbuffer); } else { *options ^= DBR_PRECISION; /*Turn off DBR_PRECISION*/ } pbuffer += dbr_precision_size; } if( (*options) & DBR_TIME ) { epicsUInt32 *ptime = (epicsUInt32 *)pbuffer; if (!pfl || pfl->type == dbfl_type_rec) { *ptime++ = pcommon->time.secPastEpoch; *ptime++ = pcommon->time.nsec; } else { *ptime++ = pfl->time.secPastEpoch; *ptime++ = pfl->time.nsec; } pbuffer = (char *)ptime; } if( (*options) & DBR_ENUM_STRS ) get_enum_strs(paddr, &pbuffer, prset, options); if( (*options) & (DBR_GR_LONG|DBR_GR_DOUBLE )) get_graphics(paddr, &pbuffer, prset, options); if((*options) & (DBR_CTRL_LONG | DBR_CTRL_DOUBLE )) get_control(paddr, &pbuffer, prset, options); if((*options) & (DBR_AL_LONG | DBR_AL_DOUBLE )) get_alarm(paddr, &pbuffer, prset, options); *poriginal = pbuffer; }