banlist_client_entry_t *banlist_client_add (banlist_client_t * list, unsigned char *client,
double minVersion, double maxVersion, buffer_t * reason)
{
banlist_client_entry_t *b;
/* delete any prior ban of this client */
banlist_client_del_byclient (list, client, minVersion, maxVersion);
/* alloc and clear new element */
b = malloc (sizeof (banlist_client_entry_t));
/* init */
dllist_init (&b->dllist);
strncpy (b->client, client, NICKLENGTH);
b->client[NICKLENGTH - 1] = 0;
b->minVersion = minVersion;
b->maxVersion = maxVersion;
if (reason) {
b->message = bf_copy (reason, 1);
} else
b->message = bf_alloc (1);
*b->message->e = 0;
/* put in hashlist */
dlhashlist_prepend (list, SuperFastHash (client, strlen (client)) & BANLIST_NICK_HASHMASK, b);
return b;
}
int bf_exp_cmplx( COMPLEX *z, COMPLEX *e)
{
FLOAT x, y, xp, cy, sy;
bf_copy( &z->real, &x);
bf_copy( &z->imag, &y);
if( !bf_exp( &x, &xp) )
{
bf_copy( &xp, &e->real);
bf_null( &e->imag);
return 0;
}
bf_cosine( &y, &cy);
// printfloat("cos(y)=", &cy);
bf_sine( &y, &sy);
// printfloat("sin(y)=", &sy);
bf_multiply( &xp, &cy, &e->real);
// printfloat("exp(x)=", &xp);
bf_multiply( &xp, &sy, &e->imag);
return 1;
}
/* compute first two terms of j(tau) sequence
j ~ 1/q + 744
returns q = exp(2*i*PI*tau) as well as j.
*/
void bf_firstj( COMPLEX *tau, COMPLEX *q, COMPLEX *j)
{
COMPLEX top, ipi;
bf_null_cmplx( &ipi);
bf_copy( &P2, &ipi.imag);
ipi.imag.expnt += 2;
bf_multiply_cmplx( &ipi, tau, q);
bf_exp_cmplx( q, q);
bf_null_cmplx( &top);
bf_one( &top.real);
bf_divide_cmplx( &top, q, j);
bf_int_to_float( 744, &top.real);
bf_add_cmplx( &top, j, j);
}
banlist_entry_t *banlist_add (banlist_t * list, unsigned char *op, unsigned char *nick, uint32_t ip,
uint32_t netmask, buffer_t * reason, unsigned long expire)
{
banlist_entry_t *b;
uint32_t i;
unsigned char n[NICKLENGTH];
unsigned int l;
/* bad netmask */
i = netmask_to_numbits (netmask);
if (i > 32)
return NULL;
l = nicktolower (n, nick);
/* delete any earlier bans of this ip. */
if ((b = banlist_find_exact (list, nick, ip, netmask)))
banlist_del (list, b);
/* alloc and clear new element */
b = malloc (sizeof (banlist_entry_t));
/* init */
dllist_init (&b->list_ip);
dllist_init (&b->list_name);
strncpy (b->nick, nick, NICKLENGTH);
b->nick[NICKLENGTH - 1] = 0;
strncpy (b->op, op, NICKLENGTH);
b->op[NICKLENGTH - 1] = 0;
b->ip = ip & netmask;
b->netmask = netmask;
b->message = bf_copy (reason, 1);
*b->message->e = 0;
b->expire = expire;
/* mask netmask as used */
list->netmask_inuse[i]++;
/* put in hashlist */
dlhashlist_prepend (&list->list_ip, one_at_a_time (ip & netmask) & BANLIST_HASHMASK,
(&b->list_ip));
dlhashlist_prepend (&list->list_name, SuperFastHash (n, l) & BANLIST_NICK_HASHMASK,
(&b->list_name));
return b;
}
static void __ice_agent_initialize(struct ice_agent *ag) {
struct call_media *media = ag->media;
struct call *call = ag->call;
ag->candidate_hash = g_hash_table_new(__cand_hash, __cand_equal);
ag->pair_hash = g_hash_table_new(__pair_hash, __pair_equal);
ag->transaction_hash = g_hash_table_new(__trans_hash, __trans_equal);
ag->foundation_hash = g_hash_table_new(__found_hash, __found_equal);
ag->agent_flags = 0;
bf_copy(&ag->agent_flags, ICE_AGENT_CONTROLLING, &media->media_flags, MEDIA_FLAG_ICE_CONTROLLING);
ag->local_interface = media->interface;
ag->desired_family = media->desired_family;
ag->nominated_pairs = g_tree_new(__pair_prio_cmp);
ag->valid_pairs = g_tree_new(__pair_prio_cmp);
ag->succeeded_pairs = g_tree_new(__pair_prio_cmp);
ag->all_pairs = g_tree_new(__pair_prio_cmp);
create_random_ice_string(call, &ag->ufrag[1], 8);
create_random_ice_string(call, &ag->pwd[1], 26);
}
main()
{
FLOAT o1, dcubed, n, *offset;
INDEX i, j, k, limit;
MULTIPOLY sigma3;
MULTIPOLY q24, tau1, tau2;
MULTIPOLY joftop, jofbot, joftau;
FLOAT *coef, *tsubj, *tnew, *prevc;
FLOAT bctop, bcbottom;
int shift, maxstore;
MULTIPOLY cheb[100];
struct
{
ELEMENT x, y;
COMPLEX start, jt;
} datablock;
FILE *svplot;
COMPLEX tau, jtau, arc[512], q, qn;
FLOAT theta, dtheta;
COMPLEX temp;
limit = 50;
maxstore = limit+5;
bf_init_ram_space();
bf_init_float();
/* create table of sigma_3(n) (sum of cube of all factors
of n).
*/
sigma3.degree = limit;
if( !bf_get_space( &sigma3))
{
printf("no space for that much data\n");
exit(0);
}
bf_one( &o1);
bf_null( &n);
for( i=1; i<limit; i++)
{
bf_add( &o1, &n, &n);
bf_multiply( &n, &n, &dcubed);
bf_multiply( &n, &dcubed, &dcubed);
for( j=i; j<limit; j+=i)
{
offset = Address( sigma3) + j;
bf_add( &dcubed, offset, offset);
}
}
/* save to disk here if necessary */
/* for( i=0; i<limit; i++)
{
tsubj = Address( sigma3) + i;
printf("i=%d\n", i);
printfloat("sigma3(i) = ", tsubj);
}
/* compute Ramanujan's tau function to some ridiculous degree.
First step is compute coefficients of (1-x)^24 using
binomial expansion.
*/
q24.degree = 24;
if( !bf_get_space( &q24))
{
printf("no room for binomial coefficients?\n");
exit(0);
}
coef = Address(q24);
bf_int_to_float( 1, coef);
bf_int_to_float( 24, &bctop);
bf_int_to_float( 1, &bcbottom);
for( i=1; i<=24; i++)
{
prevc = coef;
coef = Address(q24) + i;
bf_multiply( prevc, &bctop, coef);
bf_divide( coef, &bcbottom, coef);
bf_negate( coef);
bf_round( coef, coef);
/* printf("i= %d\n", i);
printfloat(" coef =", coef);
/* decrement top and increment bottom for next term
in binomial expansion */
bf_subtract( &bctop, &o1, &bctop);
bf_add( &o1, &bcbottom, &bcbottom);
}
/* now compute Ramanujan's tau.
Keep two versions, a source and a destination.
work back and forth multiplying source by
binomial coefficients and sum to power shifted
location. Seeking coefficients for each power
of q: q*product( 1- q^n)^24 n = 1 to infinity.
*/
tau1.degree = maxstore;
tau2.degree = maxstore;
if( !bf_get_space( &tau1))
{
printf("can't allocate first tau block.\n");
exit(0);
}
if( !bf_get_space( &tau2))
{
printf("can't allocate second tau block.\n");
exit(0);
}
coef = Address( q24);
tnew = Address( tau1);
bf_multi_copy( 25, coef, tnew);
k = 2;
while( k<maxstore ) /* loop over products */
{
/* multiply by 1, first coefficient of each product term */
prevc = Address( tau1);
tnew = Address( tau2);
bf_multi_copy( maxstore, prevc, tnew);
/* for each coefficient in 24 term product of next term,
multiply by every term in previous product and sum
to shifted location. */
for( i=1; i <= 24; i++)
{
coef = Address( q24) + i;
shift = k*i;
if( shift > maxstore) continue;
for( j=0; j<= k*24; j++)
{
if( j + shift > maxstore) continue;
tsubj = Address( tau1) + j;
tnew = Address( tau2) + j + shift;
bf_multiply( tsubj, coef, &bctop);
bf_add( &bctop, tnew, tnew);
bf_round( tnew, tnew);
}
}
k++;
/* now flip things over and go back to tau 1 */
if( k>maxstore) break;
prevc = Address( tau2);
tnew = Address( tau1);
bf_multi_copy( maxstore, prevc, tnew);
for( i=1; i<=24; i++)
{
coef = Address(q24) + i;
shift = k*i;
if( shift > maxstore) continue;
for( j=0; j<= k*24; j++)
{
if( j + shift > maxstore) continue;
tsubj = Address( tau2) + j;
tnew = Address( tau1) + j + shift;
bf_multiply( tsubj, coef, &bctop);
bf_add( &bctop, tnew, tnew);
bf_round( tnew, tnew);
}
}
k++;
}
/* compute top polynomial of joftau
(1 + 240*sum(sigma3(n)*q^n))^3 */
bf_multi_dup( sigma3, &joftop);
coef = Address( joftop);
bf_int_to_float( 1, coef);
bf_int_to_float( 240, &bctop);
for( i=1; i<limit; i++)
{
coef = Address( joftop) + i;
bf_multiply( &bctop, coef, coef);
}
bf_power_mul( joftop, joftop, &joftau);
bf_power_mul( joftop, joftau, &joftop);
/* finally compute joftau coefficients */
bf_power_div( joftop, tau1, &joftau);
/* for( i=0; i<limit; i++)
{
tsubj = Address( joftau) + i;
printf("i=%d\n", i);
printfloat("joftau(i) = ", tsubj);
}
*/
/* region F is defined as | Re(tau) | < 1/2 and || tau || > 1.
For each point tau in F, find j(tau).
save binary data to disk. Format is (x, y) and (start,
end) where x and y are integer indexes, and start, end
are complex points. Initial start is an arc along
tau = 1.
*/
svplot = fopen("joftau.complex", "wb");
if( !svplot)
{
printf( "can't create output file\n");
exit(0);
}
/* create an arc along bottom of F */
bf_copy( &P2, &theta);
theta.expnt += 2; // create 2PI/3
bf_int_to_float( 3, &n);
bf_divide( &theta, &n, &theta);
bf_copy( &theta, &dtheta);
dtheta.expnt--; // create PI/3/511
bf_int_to_float( gridsize-1, &n);
bf_divide( &dtheta, &n, &dtheta);
for( i=0; i<gridsize; i++)
{
bf_cosine( &theta, &arc[i].real);
bf_sine( &theta, &arc[i].imag);
bf_subtract( &theta, &dtheta, &theta);
}
/* Move arc up F, and find j(tau) for each point */
bf_int_to_float( 10, &bctop);
bf_int_to_float( gridsize, &n);
bf_divide( &bctop, &n, &bctop); // upper limit of F
for( i=0; i<gridsize; i++)
{
printf("i= %d\n", i);
bf_int_to_float(i, &n);
bf_multiply( &bctop, &n, &tau.imag);
bf_null( &tau.real);
datablock.y = i;
for( j=0; j<gridsize; j++)
{
datablock.x = j;
bf_add_cmplx( &tau, &arc[j], &datablock.start);
// print_cmplx("data block start", &datablock.start);
/* compute j(tau) for this point. Note power of q = index - 1 */
bf_firstj( &datablock.start, &q, &jtau);
// print_cmplx("q = exp(2 i PI tau)", &q);
// print_cmplx("first terms", &jtau);
bf_copy_cmplx( &q, &qn);
for( k=2; k<limit; k++)
{
offset = Address( joftau) + k;
bf_multiply( offset, &qn.real, &temp.real);
bf_multiply( offset, &qn.imag, &temp.imag);
bf_add_cmplx( &temp, &jtau, &jtau);
bf_multiply_cmplx( &q, &qn, &qn);
}
/* save data point to disk */
// print_cmplx("j(tau) = ", &jtau);
bf_copy_cmplx( &jtau, &datablock.jt);
if( fwrite( &datablock, sizeof( datablock), 1, svplot) <= 0)
printf("can't write to disk\n");
}
}
fclose( svplot);
printf("all done!\n\n");
}
