static int dialer_process(struct modem *m, int16_t * in, int16_t * out,
unsigned int count)
{
struct dialer_struct *s = (struct dialer_struct *)m->datapump.dp;
enum dialer_states new_state;
const char *p;
int ret = 0;
switch (s->state) {
case STATE_WAIT:
ret = detector_process(&s->detector, in, count);
memset(out, 0, ret * sizeof(int16_t));
break;
case STATE_DIAL:
ret = dtmfgen_process(&s->dtmfgen, out, count);
break;
default:
return -1;
}
if (ret == count)
return count;
if (ret < 0)
return ret;
memset(out + ret, 0, (count - ret) * sizeof(int16_t));
if (s->state == STATE_DIAL)
p = s->d_ptr = s->dtmfgen.p;
else
p = s->d_ptr++;
if (*p == '\0') {
dbg("dialer finished\n");
m->next_dp_id = DP_DETECTOR;
new_state = STATE_FINISHED;
} else if (tolower(*p) == 'w' || *p == ',') {
unsigned int pause_time = m->sregs[8] > 0 ? m->sregs[8] : 2;
new_state = STATE_WAIT;
detector_init(&s->detector, samples_in_sec(pause_time));
} else {
new_state = STATE_DIAL;
dtmfgen_init(&s->dtmfgen, p);
}
dbg("dialer state: %s -> %s\n",
STATE_NAME(s->state), STATE_NAME(new_state));
s->state = new_state;
return count;
}
/* =============================================================================
* stream_generate
* -- Returns number of attacks generated
* =============================================================================
*/
long
stream_generate (stream_t* streamPtr,
dictionary_t* dictionaryPtr,
long numFlow,
long seed,
long maxLength)
{
long numAttack = 0;
long percentAttack = streamPtr->percentAttack;
random_t* randomPtr = streamPtr->randomPtr;
vector_t* allocVectorPtr = streamPtr->allocVectorPtr;
queue_t* packetQueuePtr = streamPtr->packetQueuePtr;
MAP_T* attackMapPtr = streamPtr->attackMapPtr;
detector_t* detectorPtr = detector_alloc();
detector_addPreprocessor(detectorPtr, &preprocessor_toLower);
random_seed(randomPtr, seed);
queue_clear(packetQueuePtr);
long range = '~' - ' ' + 1;
long f;
for (f = 1; f <= numFlow; f++) {
char* str;
if ((random_generate(randomPtr) % 100) < percentAttack) {
long s = random_generate(randomPtr) % global_numDefaultSignature;
str = dictionary_get(dictionaryPtr, s);
bool_t status =
MAP_INSERT(attackMapPtr, (void*)f, (void*)str);
numAttack++;
} else {
/*
* Create random string
*/
long length = (random_generate(randomPtr) % maxLength) + 1;
str = (char*)malloc((length + 1) * sizeof(char));
bool_t status = vector_pushBack(allocVectorPtr, (void*)str);
long l;
for (l = 0; l < length; l++) {
str[l] = ' ' + (char)(random_generate(randomPtr) % range);
}
str[l] = '\0';
char* str2 = (char*)malloc((length + 1) * sizeof(char));
strcpy(str2, str);
error_t error = detector_process(detectorPtr, str2); /* updates in-place */
if (error == ERROR_SIGNATURE) {
bool_t status = MAP_INSERT(attackMapPtr,
(void*)f,
(void*)str);
numAttack++;
}
free(str2);
}
splitIntoPackets(str, f, randomPtr, allocVectorPtr, packetQueuePtr);
}
queue_shuffle(packetQueuePtr, randomPtr);
detector_free(detectorPtr);
return numAttack;
}
