int DBUtil::QueryForString(char* buf, size_t buflen, const char* sql, ...)
{
SQL_INST* sqlinst = (SQL_INST*)dbHandle_;
if(sqlinst == 0) {
radlog(L_CONS|L_ERROR, "[DBUtil::QueryForString] invalid instance");
return -1;
}
char sqlbuf[4096];
va_list args;
va_start(args, sql);
vsNprintf(sqlbuf, sizeof(sqlbuf), sql, args);
va_end(args);
Row row;
int result = SelectFirstRowInternal(sqlinst, sqlbuf, row);
if(result < 0)
strNcpy(buf, "<DBERROR>", buflen);
else if(result == 0)
strNcpy(buf, "<NORESULT>", buflen);
else
strNcpy(buf, row[0].c_str(), buflen);
return result;
}
/*
* Set the SQL user name.
*
* We don't call the escape function here. The resulting string
* will be escaped later in the queries xlat so we don't need to
* escape it twice. (it will make things wrong if we have an
* escape candidate character in the username)
*/
static int sql_set_user(SQL_INST *inst, REQUEST *request, char *sqlusername, const char *username)
{
VALUE_PAIR *vp=NULL;
char tmpuser[MAX_STRING_LEN];
tmpuser[0] = '\0';
sqlusername[0]= '\0';
/* Remove any user attr we added previously */
pairdelete(&request->packet->vps, PW_SQL_USER_NAME);
if (username != NULL) {
strNcpy(tmpuser, username, MAX_STRING_LEN);
} else if (strlen(inst->config->query_user)) {
radius_xlat(tmpuser, sizeof(tmpuser), inst->config->query_user, request, NULL);
} else {
return 0;
}
if (*tmpuser) {
strNcpy(sqlusername, tmpuser, MAX_STRING_LEN);
DEBUG2("rlm_sql (%s): sql_set_user escaped user --> '%s'",
inst->config->xlat_name, sqlusername);
vp = pairmake("SQL-User-Name", sqlusername, 0);
if (vp == NULL) {
radlog(L_ERR, "%s", librad_errstr);
return -1;
}
pairadd(&request->packet->vps, vp);
return 0;
}
return -1;
}
int32_t krd4set_S(CSOUND *csound, KREAD4 *p)
{
/* open in curdir or pathname */
char soundiname[1024];
if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
return csound->InitError(csound, Str("unknown format request"));
}
if (UNLIKELY(p->format == 2 || p->format == 3)) {
return csound->InitError(csound,
Str("alaw and ulaw not implemented here"));
}
strNcpy(soundiname, ((STRINGDAT *)p->ifilcod)->data, 1023);
if (p->fdch.fd != NULL)
fdclose(csound, &(p->fdch));
p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
"SFDIR;SSDIR", dumpf_format_table[p->format], 0);
if (UNLIKELY(p->fdch.fd == NULL))
return csound->InitError(csound, Str("Cannot open %s"), soundiname);
fdrecord(csound, &p->fdch);
if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
p->timcount = 1;
p->countdown = 0;
p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
return OK;
}
int32_t kdmpset_p(CSOUND *csound, KDUMP *p)
{
/* open in curdir or pathname */
char soundoname[1024];
if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
return csound->InitError(csound, Str("unknown format request"));
}
if (UNLIKELY(p->format == 2 || p->format == 3)) {
return csound->InitError(csound,
Str("alaw and ulaw not implemented here"));
}
if (csound->ISSTRCOD(*p->ifilcod))
strNcpy(soundoname, get_arg_string(csound, *p->ifilcod), 1023);
else csound->strarg2name(csound, soundoname, p->ifilcod, "dumpk.", 0);
if (p->fdch.fd != NULL)
fdclose(csound, &(p->fdch));
p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
"wb", "", dumpf_format_table[p->format], 0);
if (UNLIKELY(p->fdch.fd == NULL))
return csound->InitError(csound, Str("Cannot open %s"), soundoname);
fdrecord(csound, &p->fdch);
if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
p->timcount = 1;
p->countdown = p->timcount;
return OK;
}
int32_t krdsset_p(CSOUND *csound, KREADS *p)
{
/* open in curdir or pathname */
char soundiname[1024];
if (csound->ISSTRCOD(*p->ifilcod))
strNcpy(soundiname, get_arg_string(csound, *p->ifilcod), 1023);
else csound->strarg2name(csound, soundiname, p->ifilcod, "readk.", 0);
if (p->fdch.fd != NULL)
fdclose(csound, &(p->fdch));
p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
"SFDIR;SSDIR", 0, 0);
if (UNLIKELY(p->fdch.fd == NULL))
return csound->InitError(csound, Str("Cannot open %s"), soundiname);
fdrecord(csound, &p->fdch);
if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
p->timcount = 1;
p->countdown = 0;
p->lasts = (char*)csound->Malloc(csound, INITSIZE);
p->lasts[0] = '\0';
if (p->str->data == NULL) {
p->str->data = csound->Calloc(csound, INITSIZE);
p->str->size = INITSIZE;
}
return OK;
}
int32_t pvreadset_(CSOUND *csound, PVREAD *p, int32_t stringname)
{
char pvfilnam[256];
if (stringname==0){
if (csound->ISSTRCOD(*p->ifilno))
strNcpy(pvfilnam,get_arg_string(csound, *p->ifilno), MAXNAME);
else csound->strarg2name(csound, pvfilnam, p->ifilno, "pvoc.",0);
}
else strNcpy(pvfilnam, ((STRINGDAT *)p->ifilno)->data, MAXNAME);
if (pvocex_loadfile(csound, pvfilnam, p) == OK) {
p->prFlg = 1;
p->mybin = MYFLT2LRND(*p->ibin);
return OK;
}
return NOTOK;
}
void addr_parse_hostspec(char *hoststr, size_t hoststr_sz,
char *service, size_t service_sz, const char *hostspec)
{
strNcpy(hoststr, hostspec + (hostspec[0] == '['), hoststr_sz);
char *ptr = strchr(hoststr, ']');
if (!ptr)
ptr = hoststr;
else
*ptr++ = '\0';
ptr = strchr(ptr, ':');
if (ptr) {
if (service && service_sz)
strNcpy(service, ptr+1, service_sz);
*ptr = '\0';
} else {
if (service && service_sz)
service[0] = '\0';
}
}
int32_t kreads(CSOUND *csound, KREADS *p)
{
if (--p->countdown <= 0) {
p->countdown = p->timcount;
if (UNLIKELY(fgets(p->lasts, INITSIZE-1, p->f)==NULL)) {
csound->PerfError(csound, &(p->h), Str("Read failure in readks"));
}
}
strNcpy((char*) p->str->data, p->lasts, INITSIZE);
return OK;
}
int cardJobLoadCfg(struct _cardJob *j,char *_iccid,char *filename) { // Loads Info from a file
if (!j) j = &cardJob;
if (!filename) filename="/root/.telco/sims.cfg";
FILE *f = fopen(filename,"r");
if (!f) { printf("Load File %s failed\n",filename); return -2; }
char buf[1024];
while( fgets(buf,sizeof(buf),f) ) {
uchar *c=buf;
uchar *iccid = get_word(&c);
if (strcmp(iccid,_iccid)==0) { // found !
//printf("FOUND! <%s>\n",c);
strNcpy( j->ICCID, iccid );
sscanf( get_wordl(&c,4) ,"%04X", &j->spi); sscanf( get_wordl(&c,2) ,"%02X", &j->kic); sscanf( get_wordl(&c,2) ,"%04X", &j->kid);
//printf("Line2\n");
hexstr2bin( j->tar, get_wordl(&c,3),-1); hexstr2bin( j->KIC, get_wordl(&c,24*2),-1); hexstr2bin( j->KID, get_wordl(&c,24*2),-1);
//printf("Line3\n");
uchar *s = get_wordl(&c,24); strNcpy(j->MSISDN,s);
s = get_wordl(&c,24); strNcpy(j->IMSI,s);
sscanf( get_wordl(&c,4) ,"%04X", &j->counter);
fclose(f);
//printf("NOW - update counter\n");
mkdir("/root/.telco",S_IRWXU); mkdir("/root/.telco/counter",S_IRWXU); // ensure dir exists
// Now - update counter - if any
sprintf(buf,"/root/.telco/counter/%s",j->ICCID);
f = fopen(buf,"r");
if (f) {
if (fgets(buf,sizeof(buf),f)) if (sscanf(buf,"%x",&j->counter)) {
//printf("CounterUpdated: %d, hex:%x\n",j->counter,j->counter);
}
fclose(f);
}
j->saveCounter = cardJobSaveCounter;
//exit(1222);
return 1; // OK - config loaded
}
}
fclose(f);
printf("DataFor ICCID %s not found\n",_iccid);
return 0;
}
void cardJobSetup(struct _cardJob *j,
int spi, int kic, int kid, // profile data
uchar *ICCID,
uchar *KIC, uchar *KID, // personal data
int counter) {
if (j==0) j = &cardJob; /// default global
//printf("j=%x\n",j);
j->spi = spi; j->kic = kic; j->kid = kid;
strNcpy(j->ICCID,ICCID);
hexstr2bin(j->KID,KID,-1); // copy pair?
hexstr2bin(j->KIC,KIC,-1);
j->counter = counter;
}
int gmodem_sim800_wget(gmodem *g,char *url,char *buf,int size) {
int csq = 0;
char ip[20]; buf[0]=0;
gmodem_logf(g,3,"sim800.wget:check GSM coverage");
if (gmodem_csq(g,&csq)<=0) return gmodem_errorf(g,-3,"GSM not connected");
gmodem_logf(g,3,"sim800.wget:check GPRS bearer");
if (gmodem_sim800_getip(g,ip)>0) {
gmodem_logf(g,3,"sim800.wget: modem has IP address: %s",ip);
} else {
char *apn = gmodem_get_default_apn(g);
if (gmodem_sim800_ip_attach(g,apn )<=0) return 0;
}
//char buf[300]; int len=sizeof(buf);
gmodem_logf(g,3,"sim800.wget ready for http");
int code = gmodem_sim800_http_connect(g,url,60); if (code<=0) return code; // gmodem_errorf(g,-3,"wget http_connect failed");
int len = size-1;
if( len > g->http_len) len=g->http_len;
int ok = gmodem_sim800_http_read(g,buf,len); // read one block
if (ok<=0) return -1;
strNcpy(g->out,buf); // copy to state
return 1;
}
static int32_t pvsfreadset_(CSOUND *csound, PVSFREAD *p, int32_t stringname)
{
PVOCEX_MEMFILE pp;
uint32 N;
char pvfilnam[MAXNAME];
if (stringname) strNcpy(pvfilnam, ((STRINGDAT*)p->ifilno)->data, MAXNAME-1);
else if (csound->ISSTRCOD(*p->ifilno))
strNcpy(pvfilnam, get_arg_string(csound, *p->ifilno), MAXNAME-1);
else csound->strarg2name(csound, pvfilnam, p->ifilno, "pvoc.", 0);
if (UNLIKELY(PVOCEX_LoadFile(csound, pvfilnam, &pp) != 0)) {
return csound->InitError(csound, Str("Failed to load PVOC-EX file"));
}
p->ptr = 0;
p->overlap = pp.overlap;
p->winsize = pp.winsize;
p->fftsize = pp.fftsize;
p->wintype = pp.wintype;
p->format = pp.format;
p->chans = pp.chans;
p->nframes = pp.nframes;
p->arate = csound->esr / (MYFLT) pp.overlap;
p->membase = (float*) pp.data;
if (UNLIKELY(p->overlap < (int32_t)CS_KSMPS || p->overlap < 10))
return csound->InitError(csound, Str("Sliding version not yet available"));
if (UNLIKELY(p->nframes <= 0))
return csound->InitError(csound, Str("pvsfread: file is empty!\n"));
/* special case if only one frame - it is an impulse response */
if (UNLIKELY(p->nframes == 1))
return csound->InitError(csound, Str("pvsfread: file has only one frame "
"(= impulse response).\n"));
if (UNLIKELY(p->overlap < (int32_t)CS_KSMPS))
return csound->InitError(csound, Str("pvsfread: analysis frame overlap "
"must be >= ksmps\n"));
p->blockalign = (p->fftsize+2) * p->chans;
if (UNLIKELY((*p->ichan) >= p->chans))
return csound->InitError(csound, Str("pvsfread: ichan value exceeds "
"file channel count.\n"));
if (UNLIKELY((int32_t) (*p->ichan) < 0))
return csound->InitError(csound,
Str("pvsfread: ichan cannot be negative.\n"));
N = p->fftsize;
/* setup output signal */
csound->AuxAlloc(csound, (N + 2) * sizeof(float), &p->fout->frame);
/* init sig with first frame from file,
regardless (always zero amps, but with bin freqs) */
p->chanoffset = (int32_t) MYFLT2LRND(*p->ichan) * (N + 2);
memcpy((float *) p->fout->frame.auxp, /* RWD MUST be 32bit */
(float *) pp.data + (int32_t) p->chanoffset, /* RWD MUST be 32bit */
(size_t) ((int32_t) (N + 2) * (int32_t) sizeof(float)));
p->membase += p->blockalign; /* move to 2nd frame in file, as startpoint */
p->nframes--;
p->fout->N = N;
p->fout->overlap = p->overlap;
p->fout->winsize = p->winsize;
p->fout->wintype = p->wintype;
p->fout->format = p->format;
p->fout->framecount = 1;
p->lastframe = 0;
return OK;
}
static int sendrecv_eap(RADIUS_PACKET *rep)
{
RADIUS_PACKET *req = NULL;
VALUE_PAIR *vp, *vpnext;
int tried_eap_md5 = 0;
/*
* Keep a copy of the the User-Password attribute.
*/
if ((vp = pairfind(rep->vps, ATTRIBUTE_EAP_MD5_PASSWORD)) != NULL) {
strNcpy(password, (char *)vp->strvalue, sizeof(vp->strvalue));
} else if ((vp = pairfind(rep->vps, PW_PASSWORD)) != NULL) {
strNcpy(password, (char *)vp->strvalue, sizeof(vp->strvalue));
/*
* Otherwise keep a copy of the CHAP-Password attribute.
*/
} else if ((vp = pairfind(rep->vps, PW_CHAP_PASSWORD)) != NULL) {
strNcpy(password, (char *)vp->strvalue, sizeof(vp->strvalue));
} else {
*password = '******';
}
again:
rep->id++;
printf("\n+++> About to send encoded packet:\n");
vp_printlist(stdout, rep->vps);
/*
* if there are EAP types, encode them into an EAP-Message
*
*/
map_eap_types(rep);
/*
* Fix up Digest-Attributes issues
*/
for (vp = rep->vps; vp != NULL; vp = vp->next) {
switch (vp->attribute) {
default:
break;
case PW_DIGEST_REALM:
case PW_DIGEST_NONCE:
case PW_DIGEST_METHOD:
case PW_DIGEST_URI:
case PW_DIGEST_QOP:
case PW_DIGEST_ALGORITHM:
case PW_DIGEST_BODY_DIGEST:
case PW_DIGEST_CNONCE:
case PW_DIGEST_NONCE_COUNT:
case PW_DIGEST_USER_NAME:
/* overlapping! */
memmove(&vp->strvalue[2], &vp->strvalue[0], vp->length);
vp->strvalue[0] = vp->attribute - PW_DIGEST_REALM + 1;
vp->length += 2;
vp->strvalue[1] = vp->length;
vp->attribute = PW_DIGEST_ATTRIBUTES;
break;
}
}
/*
* If we've already sent a packet, free up the old
* one, and ensure that the next packet has a unique
* ID and authentication vector.
*/
if (rep->data) {
free(rep->data);
rep->data = NULL;
}
librad_md5_calc(rep->vector, rep->vector,
sizeof(rep->vector));
if (*password != '\0') {
if ((vp = pairfind(rep->vps, PW_PASSWORD)) != NULL) {
strNcpy((char *)vp->strvalue, password, strlen(password) + 1);
vp->length = strlen(password);
} else if ((vp = pairfind(rep->vps, PW_CHAP_PASSWORD)) != NULL) {
strNcpy((char *)vp->strvalue, password, strlen(password) + 1);
vp->length = strlen(password);
rad_chap_encode(rep, (char *) vp->strvalue, rep->id, vp);
vp->length = 17;
}
} /* there WAS a password */
/* send the response, wait for the next request */
send_packet(rep, &req);
/* okay got back the packet, go and decode the EAP-Message. */
unmap_eap_types(req);
printf("<+++ EAP decoded packet:\n");
vp_printlist(stdout, req->vps);
/* now look for the code type. */
for (vp = req->vps; vp != NULL; vp = vpnext) {
vpnext = vp->next;
switch (vp->attribute) {
default:
break;
case ATTRIBUTE_EAP_BASE+PW_EAP_MD5:
if(respond_eap_md5(req, rep) && tried_eap_md5 < 3)
{
tried_eap_md5++;
goto again;
}
break;
case ATTRIBUTE_EAP_BASE+PW_EAP_SIM:
if(respond_eap_sim(req, rep))
{
goto again;
}
break;
}
}
return 1;
}
/*
* Calculate/check digest, and decode radius attributes.
*/
int rad_decode(RADIUS_PACKET *packet, RADIUS_PACKET *original,
const char *secret)
{
DICT_ATTR *attr;
uint32_t lvalue;
uint32_t vendorcode;
VALUE_PAIR **tail;
VALUE_PAIR *pair;
uint8_t *ptr;
int length;
int attribute;
int attrlen;
int vendorlen;
radius_packet_t *hdr;
hdr = (radius_packet_t *)packet->data;
/*
* Before we allocate memory for the attributes, do more
* sanity checking.
*/
ptr = hdr->data;
length = packet->data_len - AUTH_HDR_LEN;
while (length > 0) {
uint8_t msg_auth_vector[AUTH_VECTOR_LEN];
uint8_t calc_auth_vector[AUTH_VECTOR_LEN];
attrlen = ptr[1];
switch (ptr[0]) {
default: /* don't do anything. */
break;
/*
* Note that more than one Message-Authenticator
* attribute is invalid.
*/
case PW_MESSAGE_AUTHENTICATOR:
memcpy(msg_auth_vector, &ptr[2], sizeof(msg_auth_vector));
memset(&ptr[2], 0, AUTH_VECTOR_LEN);
switch (packet->code) {
default:
break;
case PW_AUTHENTICATION_ACK:
case PW_AUTHENTICATION_REJECT:
case PW_ACCESS_CHALLENGE:
if (original) {
memcpy(packet->data + 4, original->vector, AUTH_VECTOR_LEN);
}
break;
}
lrad_hmac_md5(packet->data, packet->data_len,
secret, strlen(secret), calc_auth_vector);
if (memcmp(calc_auth_vector, msg_auth_vector,
sizeof(calc_auth_vector)) != 0) {
char buffer[32];
librad_log("Received packet from %s with invalid Message-Authenticator! (Shared secret is incorrect.)",
ip_ntoa(buffer, packet->src_ipaddr));
return 1;
} /* else the message authenticator was good */
/*
* Reinitialize Authenticators.
*/
memcpy(&ptr[2], msg_auth_vector, AUTH_VECTOR_LEN);
memcpy(packet->data + 4, packet->vector, AUTH_VECTOR_LEN);
break;
} /* switch over the attributes */
ptr += attrlen;
length -= attrlen;
} /* loop over the packet, sanity checking the attributes */
/*
* Calculate and/or verify digest.
*/
switch(packet->code) {
int rcode;
case PW_AUTHENTICATION_REQUEST:
case PW_STATUS_SERVER:
case PW_DISCONNECT_REQUEST:
/*
* The authentication vector is random
* nonsense, invented by the client.
*/
break;
case PW_ACCOUNTING_REQUEST:
if (calc_acctdigest(packet, secret) > 1) {
char buffer[32];
librad_log("Received Accounting-Request packet "
"from %s with invalid signature! (Shared secret is incorrect.)",
ip_ntoa(buffer, packet->src_ipaddr));
return 1;
}
break;
/* Verify the reply digest */
case PW_AUTHENTICATION_ACK:
case PW_AUTHENTICATION_REJECT:
case PW_ACCOUNTING_RESPONSE:
rcode = calc_replydigest(packet, original, secret);
if (rcode > 1) {
char buffer[32];
librad_log("Received %s packet "
"from %s with invalid signature (err=%d)! (Shared secret is incorrect.)",
packet_codes[packet->code],
ip_ntoa(buffer, packet->src_ipaddr),
rcode);
return 1;
}
break;
}
/*
* Extract attribute-value pairs
*/
ptr = hdr->data;
length = packet->data_len - AUTH_HDR_LEN;
packet->vps = NULL;
tail = &packet->vps;
vendorcode = 0;
vendorlen = 0;
while(length > 0) {
if (vendorlen > 0) {
attribute = *ptr++ | (vendorcode << 16);
attrlen = *ptr++;
} else {
attribute = *ptr++;
attrlen = *ptr++;
}
attrlen -= 2;
length -= 2;
/*
* This could be a Vendor-Specific attribute.
*
*/
if ((vendorlen <= 0) &&
(attribute == PW_VENDOR_SPECIFIC) &&
(attrlen > 6)) {
memcpy(&lvalue, ptr, 4);
vendorcode = ntohl(lvalue);
if (vendorcode != 0) {
if (vendorcode == VENDORPEC_USR) {
ptr += 4;
memcpy(&lvalue, ptr, 4);
/*printf("received USR %04x\n", ntohl(lvalue));*/
attribute = (ntohl(lvalue) & 0xFFFF) |
(vendorcode << 16);
ptr += 4;
attrlen -= 8;
length -= 8;
} else {
ptr += 4;
vendorlen = attrlen - 4;
attribute = *ptr++ | (vendorcode << 16);
attrlen = *ptr++;
attrlen -= 2;
length -= 6;
}
}
/*
* Else the vendor wasn't found...
*/
}
/*
* FIXME: should we us paircreate() ?
*/
if ((pair = malloc(sizeof(VALUE_PAIR))) == NULL) {
pairfree(&packet->vps);
librad_log("out of memory");
errno = ENOMEM;
return -1;
}
memset(pair, 0, sizeof(VALUE_PAIR));
if ((attr = dict_attrbyvalue(attribute)) == NULL) {
snprintf(pair->name, sizeof(pair->name), "Attr-%d", attribute);
pair->type = PW_TYPE_OCTETS;
} else {
strcpy(pair->name, attr->name);
pair->type = attr->type;
pair->flags = attr->flags;
}
pair->attribute = attribute;
pair->length = attrlen;
pair->operator = T_OP_EQ;
pair->next = NULL;
switch (pair->type) {
case PW_TYPE_OCTETS:
case PW_TYPE_ABINARY:
case PW_TYPE_STRING:
if (pair->flags.has_tag &&
pair->type == PW_TYPE_STRING) {
int offset = 0;
if ((pair->length > 0) && TAG_VALID(*ptr)) {
pair->flags.tag = *ptr;
pair->length--;
offset = 1;
} else if (pair->flags.encrypt == FLAG_ENCRYPT_TUNNEL_PASSWORD) {
/*
* from RFC2868 - 3.5. Tunnel-Password
* If the value of the Tag field is greater than
* 0x00 and less than or equal to 0x1F, it SHOULD
* be interpreted as indicating which tunnel
* (of several alternatives) this attribute pertains;
* otherwise, the Tag field SHOULD be ignored.
*/
pair->flags.tag = 0x00;
if (pair->length > 0) pair->length--;
offset = 1;
} else {
pair->flags.tag = 0x00;
}
/*
* pair->length may be zero here...
*/
memcpy(pair->strvalue, ptr + offset,
pair->length);
} else {
/* attrlen always < MAX_STRING_LEN */
memcpy(pair->strvalue, ptr, attrlen);
pair->flags.tag = 0;
}
/*
* FIXME: HACK for non-updated dictionaries.
* REMOVE in a future release.
*/
if ((strcmp(pair->name, "Ascend-Send-Secret") == 0) ||
(strcmp(pair->name, "Ascend-Receive-Secret") == 0)) {
pair->flags.encrypt = FLAG_ENCRYPT_ASCEND_SECRET;
}
if (pair->attribute == PW_USER_PASSWORD) {
pair->flags.encrypt = FLAG_ENCRYPT_USER_PASSWORD;
}
/*
* Decrypt passwords here.
*/
switch (pair->flags.encrypt) {
default:
break;
/*
* User-Password
*/
case FLAG_ENCRYPT_USER_PASSWORD:
if (original) {
rad_pwdecode((char *)pair->strvalue,
pair->length, secret,
(char *)original->vector);
} else {
rad_pwdecode((char *)pair->strvalue,
pair->length, secret,
(char *)packet->vector);
}
if (pair->attribute == PW_USER_PASSWORD) {
pair->length = strlen(pair->strvalue);
}
break;
/*
* Tunnel-Password
*/
case FLAG_ENCRYPT_TUNNEL_PASSWORD:
if (!original) {
librad_log("ERROR: Tunnel-Password attribute in request: Cannot decrypt it.");
return -1;
}
rad_tunnel_pwdecode((char *)pair->strvalue,
&pair->length,
secret,
(char *)original->vector);
break;
/*
* Ascend-Send-Secret
* Ascend-Receive-Secret
*/
case FLAG_ENCRYPT_ASCEND_SECRET:
{
uint8_t my_digest[AUTH_VECTOR_LEN];
make_secret(my_digest,
original->vector,
secret, ptr);
memcpy(pair->strvalue, my_digest,
AUTH_VECTOR_LEN );
pair->strvalue[AUTH_VECTOR_LEN] = '\0';
pair->length = strlen(pair->strvalue);
}
break;
} /* switch over encryption flags */
break; /* from octets/string/abinary */
case PW_TYPE_INTEGER:
case PW_TYPE_DATE:
case PW_TYPE_IPADDR:
/*
* Check for RFC compliance. If the
* attribute isn't compliant, turn it
* into a string of raw octets.
*
* Also set the lvalue to something
* which should never match anything.
*/
if (attrlen != 4) {
pair->type = PW_TYPE_OCTETS;
memcpy(pair->strvalue, ptr, attrlen);
pair->lvalue = 0xbad1bad1;
break;
}
memcpy(&lvalue, ptr, 4);
if (attr->type != PW_TYPE_IPADDR) {
pair->lvalue = ntohl(lvalue);
} else {
/*
* It's an IP address, keep it in network
* byte order, and put the ASCII IP
* address or host name into the string
* value.
*/
pair->lvalue = lvalue;
ip_ntoa(pair->strvalue, pair->lvalue);
}
/*
* Only PW_TYPE_INTEGER should have tags.
*/
if (pair->flags.has_tag &&
pair->type == PW_TYPE_INTEGER) {
pair->flags.tag = (pair->lvalue >> 24) & 0xff;
pair->lvalue &= 0x00ffffff;
}
if (attr->type == PW_TYPE_INTEGER) {
DICT_VALUE *dval;
dval = dict_valbyattr(pair->attribute,
pair->lvalue);
if (dval) {
strNcpy(pair->strvalue,
dval->name,
sizeof(pair->strvalue));
}
}
break;
default:
DEBUG(" %s (Unknown Type %d)\n",
attr->name,attr->type);
free(pair);
pair = NULL;
break;
}
if (pair) {
debug_pair(pair);
*tail = pair;
tail = &pair->next;
}
ptr += attrlen;
length -= attrlen;
if (vendorlen > 0) vendorlen -= (attrlen + 2);
}
/*
* Internal function to cut down on duplicated code.
*
* Returns -1 on failure, 0 on no failure. returnrealm
* is NULL on don't proxy, realm otherwise.
*/
static int check_for_realm(void *instance, REQUEST *request, REALM **returnrealm)
{
char namebuf[MAX_STRING_LEN];
char *username;
char *realmname = NULL;
char *ptr;
VALUE_PAIR *vp;
REALM *realm;
struct realm_config_t *inst = instance;
/* initiate returnrealm */
*returnrealm = NULL;
/*
* If the request has a proxy entry, then it's a proxy
* reply, and we're walking through the module list again.
*
* In that case, don't bother trying to proxy the request
* again.
*
* Also, if there's no User-Name attribute, we can't
* proxy it, either.
*/
if ((request->proxy != NULL) ||
(request->username == NULL)) {
DEBUG2(" rlm_realm: Proxy reply, or no User-Name. Ignoring.");
return 0;
}
/*
* Check for 'Realm' attribute. If it exists, then we've proxied
* it already ( via another rlm_realm instance ) and should return.
*/
if ( (vp = pairfind(request->packet->vps, PW_REALM)) != NULL ) {
DEBUG2(" rlm_realm: Request already proxied. Ignoring.");
return 0;
}
/*
* We will be modifing this later, so we want our own copy
* of it.
*/
strNcpy(namebuf, (char *)request->username->strvalue, sizeof(namebuf));
username = namebuf;
switch(inst->format)
{
case REALM_FORMAT_SUFFIX:
/* DEBUG2(" rlm_realm: Checking for suffix after \"%c\"", inst->delim[0]); */
realmname = strrchr(username, inst->delim[0]);
if (realmname) {
*realmname = '\0';
realmname++;
}
break;
case REALM_FORMAT_PREFIX:
/* DEBUG2(" rlm_realm: Checking for prefix before \"%c\"", inst->delim[0]); */
ptr = strchr(username, inst->delim[0]);
if (ptr) {
*ptr = '\0';
ptr++;
realmname = username;
username = ptr;
}
break;
default:
realmname = NULL;
break;
}
/*
* Print out excruciatingly descriptive debugging messages
* for the people who find it too difficult to think about
* what's going on.
*/
if (realmname) {
DEBUG2(" rlm_realm: Looking up realm \"%s\" for User-Name = \"%s\"",
realmname, request->username->strvalue);
} else {
if( inst->ignore_null ) {
DEBUG2(" rlm_realm: No '%c' in User-Name = \"%s\", skipping NULL due to config.",
inst->delim[0], request->username->strvalue);
return 0;
}
DEBUG2(" rlm_realm: No '%c' in User-Name = \"%s\", looking up realm NULL",
inst->delim[0], request->username->strvalue);
}
/*
* Allow DEFAULT realms unless told not to.
*/
realm = realm_find(realmname, (request->packet->code == PW_ACCOUNTING_REQUEST));
if (!realm) {
DEBUG2(" rlm_realm: No such realm \"%s\"",
(realmname == NULL) ? "NULL" : realmname);
return 0;
}
if( inst->ignore_default &&
(strcmp(realm->realm, "DEFAULT")) == 0) {
DEBUG2(" rlm_realm: Found DEFAULT, but skipping due to config.");
return 0;
}
DEBUG2(" rlm_realm: Found realm \"%s\"", realm->realm);
/*
* If we've been told to strip the realm off, then do so.
*/
if (realm->striprealm) {
/*
* Create the Stripped-User-Name attribute, if it
* doesn't exist.
*
*/
if (request->username->attribute != PW_STRIPPED_USER_NAME) {
vp = paircreate(PW_STRIPPED_USER_NAME, PW_TYPE_STRING);
if (!vp) {
radlog(L_ERR|L_CONS, "no memory");
return -1;
}
pairadd(&request->packet->vps, vp);
DEBUG2(" rlm_realm: Adding Stripped-User-Name = \"%s\"", username);
} else {
vp = request->username;
DEBUG2(" rlm_realm: Setting Stripped-User-Name = \"%s\"", username);
}
strcpy(vp->strvalue, username);
vp->length = strlen((char *)vp->strvalue);
request->username = vp;
}
DEBUG2(" rlm_realm: Proxying request from user %s to realm %s",
username, realm->realm);
/*
* Add the realm name to the request.
*/
pairadd(&request->packet->vps, pairmake("Realm", realm->realm,
T_OP_EQ));
DEBUG2(" rlm_realm: Adding Realm = \"%s\"", realm->realm);
/*
* Figure out what to do with the request.
*/
switch (request->packet->code) {
default:
DEBUG2(" rlm_realm: Unknown packet code %d\n",
request->packet->code);
return 0; /* don't do anything */
/*
* Perhaps accounting proxying was turned off.
*/
case PW_ACCOUNTING_REQUEST:
if (realm->acct_ipaddr == htonl(INADDR_NONE)) {
DEBUG2(" rlm_realm: Accounting realm is LOCAL.");
return 0;
}
if (realm->acct_port == 0) {
DEBUG2(" rlm_realm: acct_port is not set. Proxy cancelled.");
return 0;
}
break;
/*
* Perhaps authentication proxying was turned off.
*/
case PW_AUTHENTICATION_REQUEST:
if (realm->ipaddr == htonl(INADDR_NONE)) {
DEBUG2(" rlm_realm: Authentication realm is LOCAL.");
return 0;
}
if (realm->auth_port == 0) {
DEBUG2(" rlm_realm: auth_port is not set. Proxy cancelled.");
return 0;
}
break;
}
/*
* If this request has arrived from another freeradius server
* that has already proxied the request, we don't need to do
* it again.
*/
for (vp = request->packet->vps; vp; vp = vp->next) {
if (vp->attribute == PW_FREERADIUS_PROXIED_TO) {
if (request->packet->code == PW_AUTHENTICATION_REQUEST &&
vp->lvalue == realm->ipaddr) {
DEBUG2(" rlm_realm: Request not proxied due to Freeradius-Proxied-To");
return 0;
}
if (request->packet->code == PW_ACCOUNTING_REQUEST &&
vp->lvalue == realm->acct_ipaddr) {
DEBUG2(" rlm_realm: Request not proxied due to Freeradius-Proxied-To");
return 0;
}
}
}
/*
* We got this far, which means we have a realm, set returnrealm
*/
*returnrealm = realm;
return 0;
}
static int sqlcounter_expand(char *out, int outlen, const char *fmt, void *instance)
{
rlm_sqlcounter_t *data = (rlm_sqlcounter_t *) instance;
int c,freespace;
const char *p;
char *q;
char tmpdt[40]; /* For temporary storing of dates */
int openbraces=0;
q = out;
for (p = fmt; *p ; p++) {
/* Calculate freespace in output */
freespace = outlen - (q - out);
if (freespace <= 1)
break;
c = *p;
if ((c != '%') && (c != '$') && (c != '\\')) {
/*
* We check if we're inside an open brace. If we are
* then we assume this brace is NOT literal, but is
* a closing brace and apply it
*/
if((c == '}') && openbraces) {
openbraces--;
continue;
}
*q++ = *p;
continue;
}
if (*++p == '\0') break;
if (c == '\\') switch(*p) {
case '\\':
*q++ = *p;
break;
case 't':
*q++ = '\t';
break;
case 'n':
*q++ = '\n';
break;
default:
*q++ = c;
*q++ = *p;
break;
} else if (c == '%') switch(*p) {
case '%':
*q++ = *p;
case 'b': /* last_reset */
snprintf(tmpdt, sizeof(tmpdt), "%lu", data->last_reset);
strNcpy(q, tmpdt, freespace);
q += strlen(q);
break;
case 'e': /* reset_time */
snprintf(tmpdt, sizeof(tmpdt), "%lu", data->reset_time);
strNcpy(q, tmpdt, freespace);
q += strlen(q);
break;
case 'k': /* Key Name */
strNcpy(q, data->key_name, freespace);
q += strlen(q);
break;
case 'S': /* SQL module instance */
strNcpy(q, data->sqlmod_inst, freespace);
q += strlen(q);
break;
default:
*q++ = '%';
*q++ = *p;
break;
}
}
*q = '\0';
DEBUG2("sqlcounter_expand: '%s'", out);
return strlen(out);
}
void PS_MakeGraph(CSOUND *csound, WINDAT *wdptr, const char *name)
{
winEPS_globals_t *pp;
char *filenam;
char pathnam[1024];
char *t;
time_t lt;
OPARMS oparms;
csound->GetOParms(csound, &oparms);
IGN(wdptr);
IGN(name);
if (csound->winEPS_globals != NULL)
return;
csound->winEPS_globals = csound->Calloc(csound, sizeof(winEPS_globals_t));
pp = (winEPS_globals_t *) csound->winEPS_globals;
filenam = oparms.outfilename;
if (filenam == NULL)
filenam = "test"; /* O.outfilename not set yet */
/* If sound output is being piped directly to the DAC, then */
/* there is no PS output, (psFileOK remains 0), */
/* otherwise open an encapsulated PostScript output file */
/* with a name related to the sound file's name. */
/* */
/* The PS file is located in the same directory as the */
/* sound file, and has the name of the sound file with the */
/* extension ``.eps'' appended. */
/* */
/**
* Remove extension from sound-file and add ".eps"
*/
strNcpy(pathnam, filenam, 1024); //pathnam[1023] = '\0';
t = strrchr(pathnam, '.');
if (t != NULL) *t = '\0';
strlcat(pathnam, ".eps", 1024);
pp->psfd = csound->FileOpen2(csound, &(pp->psFile), CSFILE_STD, pathnam,
"w", "SFDIR", CSFTYPE_POSTSCRIPT, 0);
if (UNLIKELY(pp->psfd == NULL)) {
csound->Message(csound, Str("** Warning ** PostScript file %s "
"cannot be opened\n"), pathnam);
csound->winEPS_globals = NULL;
csound->Free(csound, (void *)pp);
return;
}
csound->Message(csound, Str("\n PostScript graphs written to file %s\n\n"),
pathnam);
/**
* Get the current time and date
*/
lt = time(NULL);
#ifndef LINUX
{
struct tm *date_ptr;
char *date;
date_ptr = localtime(<);
date = asctime(date_ptr);
t = pp->ps_date;
while (*date != '\n')
*t++ = *date++;
*t = '\0';
}
#else
/* avoid use of non-reentrant functions */
{
struct tm tmp1;
memset(&tmp1, 0, sizeof(struct tm));
localtime_r(<, &tmp1);
asctime_r(&tmp1, &(pp->ps_date[0]));
}
#endif
/**
* Print PostScript file Header
* Place every plot on a new page.
*/
fprintf(pp->psFile, "%s \n", "%!PS-Adobe-2.0");
fprintf(pp->psFile, "%s \n", "%%Creator: Csound");
fprintf(pp->psFile, "%s %s \n", "%%CreationDate:", pp->ps_date);
fprintf(pp->psFile, "%s \n", "%%Pages: (atend)");
fprintf(pp->psFile, "%s \n", "%%PageOrder: Ascend");
fprintf(pp->psFile, "%s \n", "%%BoundingBox: 010 010 540 700");
fprintf(pp->psFile, "%s \n", "%%Orientation: Portrait");
fprintf(pp->psFile, "%s \n", "%%EndComments");
fprintf(pp->psFile, "%s \n", " ");
}
/*
* Find a module instance.
*/
module_instance_t *find_module_instance(const char *instname)
{
CONF_SECTION *cs, *inst_cs;
const char *name1, *name2;
module_instance_t *node, **last;
char module_name[256];
/*
* Look through the global module instance list for the
* named module.
*/
last = &module_instance_list;
for (node = module_instance_list; node != NULL; node = node->next) {
/*
* Found the named instance. Return it.
*/
if (strcmp(node->name, instname) == 0)
return node;
/*
* Keep a pointer to the last entry to update...
*/
last = &node->next;
}
/*
* Instance doesn't exist yet. Try to find the
* corresponding configuration section and create it.
*/
/*
* Look for the 'modules' configuration section.
*/
cs = cf_section_find("modules");
if (cs == NULL) {
radlog(L_ERR|L_CONS, "ERROR: Cannot find a 'modules' section in the configuration file.\n");
return NULL;
}
/*
* Module instances are declared in the modules{} block
* and referenced later by their name, which is the
* name2 from the config section, or name1 if there was
* no name2.
*/
name1 = name2 = NULL;
for(inst_cs=cf_subsection_find_next(cs, NULL, NULL);
inst_cs != NULL;
inst_cs=cf_subsection_find_next(cs, inst_cs, NULL)) {
name1 = cf_section_name1(inst_cs);
name2 = cf_section_name2(inst_cs);
if ( (name2 && !strcmp(name2, instname)) ||
(!name2 && !strcmp(name1, instname)) )
break;
}
if (inst_cs == NULL) {
radlog(L_ERR|L_CONS, "ERROR: Cannot find a configuration entry for module \"%s\".\n", instname);
return NULL;
}
/*
* Found the configuration entry.
*/
node = rad_malloc(sizeof(*node));
node->next = NULL;
node->insthandle = NULL;
/*
* Link to the module by name: rlm_FOO-major.minor
*/
if (strncmp(name1, "rlm_", 4)) {
#if 0
snprintf(module_name, sizeof(module_name), "rlm_%s-%d.%d",
name1, RADIUSD_MAJOR_VERSION, RADIUSD_MINOR_VERSION);
#else
snprintf(module_name, sizeof(module_name), "rlm_%s",
name1);
#endif
} else {
strNcpy(module_name, name1, sizeof(module_name));
}
/*
* FIXME: "radiusd.conf" is wrong here; must find cf filename
*/
node->entry = linkto_module(module_name, "radiusd.conf",
cf_section_lineno(inst_cs));
if (!node->entry) {
free(node);
/* linkto_module logs any errors */
return NULL;
}
/*
* Call the module's instantiation routine.
*/
if ((node->entry->module->instantiate) &&
((node->entry->module->instantiate)(inst_cs,
&node->insthandle) < 0)) {
radlog(L_ERR|L_CONS,
"radiusd.conf[%d]: %s: Module instantiation failed.\n",
cf_section_lineno(inst_cs), instname);
free(node);
return NULL;
}
/*
* We're done. Fill in the rest of the data structure,
* and link it to the module instance list.
*/
strNcpy(node->name, instname, sizeof(node->name));
#if HAVE_PTHREAD_H
/*
* If we're threaded, check if the module is thread-safe.
*
* If it isn't, we create a mutex.
*/
if ((node->entry->module->type & RLM_TYPE_THREAD_UNSAFE) != 0) {
node->mutex = (pthread_mutex_t *) rad_malloc(sizeof(pthread_mutex_t));
/*
* Initialize the mutex.
*/
pthread_mutex_init(node->mutex, NULL);
} else {
/*
* The module is thread-safe. Don't give it a mutex.
*/
node->mutex = NULL;
}
#endif
*last = node;
DEBUG("Module: Instantiated %s (%s) ", name1, node->name);
return node;
}
/*
* Find a module on disk or in memory, and link to it.
*/
static module_list_t *linkto_module(const char *module_name,
const char *cffilename, int cflineno)
{
module_list_t *node;
lt_dlhandle handle;
char module_struct[256];
char *p;
/*
* Look through the global module library list for the
* named module.
*/
for (node = module_list; node != NULL; node = node->next) {
/*
* Found the named module. Return it.
*/
if (strcmp(node->name, module_name) == 0)
return node;
}
/*
* Keep the handle around so we can dlclose() it.
*/
handle = lt_dlopenext(module_name);
if (handle == NULL) {
radlog(L_ERR|L_CONS, "%s[%d] Failed to link to module '%s':"
" %s\n", cffilename, cflineno, module_name, lt_dlerror());
return NULL;
}
/* make room for the module type */
node = (module_list_t *) rad_malloc(sizeof(module_list_t));
/* fill in the module structure */
node->next = NULL;
node->handle = handle;
strNcpy(node->name, module_name, sizeof(node->name));
/*
* Link to the module's rlm_FOO{} module structure.
*/
/* module_name has the version embedded; strip it. */
strcpy(module_struct, module_name);
p = strrchr(module_struct, '-');
if (p)
*p = '\0';
node->module = (module_t *) lt_dlsym(node->handle, module_struct);
if (!node->module) {
radlog(L_ERR|L_CONS, "%s[%d] Failed linking to "
"%s structure in %s: %s\n",
cffilename, cflineno,
module_name, cffilename, lt_dlerror());
lt_dlclose(node->handle); /* ignore any errors */
free(node);
return NULL;
}
/* call the modules initialization */
if (node->module->init && (node->module->init)() < 0) {
radlog(L_ERR|L_CONS, "%s[%d] Module initialization failed.\n",
cffilename, cflineno);
lt_dlclose(node->handle); /* ignore any errors */
free(node);
return NULL;
}
DEBUG("Module: Loaded %s ", node->module->name);
node->next = module_list;
module_list = node;
return node;
}
/*
* Initialize a radclient data structure
*/
static radclient_t *radclient_init(char * auth_statement)
{
VALUE_PAIR *vp;
radclient_t *start, *radclient, *prev = NULL;
int filedone = 0;
int packet_number = 1;
start = NULL;
/*
* Determine where to read the VP's from.
*/
/*
* Loop until the file is done.
*/
/*
* Allocate it.
*/
radclient = malloc(sizeof(*radclient));
memset(radclient, 0, sizeof(*radclient));
radclient->request = rad_alloc(1);
radclient->request->id = -1; /* allocate when sending */
radclient->packet_number = packet_number++;
/*
* Read the VP's.
*/
radclient->request->vps = readvp2(auth_statement, &filedone, "radclient: X");
if (!radclient->request->vps)
{
radclient_free(radclient);
return radclient; /* done: return the list */
}
/*
* Keep a copy of the the User-Password attribute.
*/
if ((vp = pairfind(radclient->request->vps, PW_PASSWORD)) != NULL)
{
strNcpy(radclient->password, (char *)vp->strvalue, sizeof(radclient->password));
/*
* Otherwise keep a copy of the CHAP-Password attribute.
*/
}
else if ((vp = pairfind(radclient->request->vps, PW_CHAP_PASSWORD)) != NULL)
{
strNcpy(radclient->password, (char *)vp->strvalue, sizeof(radclient->password));
}
else
{
radclient->password[0] = '\0';
}
/*
* Fix up Digest-Attributes issues
*/
for (vp = radclient->request->vps; vp != NULL; vp = vp->next)
{
switch (vp->attribute)
{
default:
break;
/*
* Allow it to set the packet type in
* the attributes read from the file.
*/
case PW_PACKET_TYPE:
radclient->request->code = vp->lvalue;
break;
case PW_PACKET_DST_PORT:
radclient->request->dst_port = (vp->lvalue & 0xffff);
break;
case PW_DIGEST_REALM:
case PW_DIGEST_NONCE:
case PW_DIGEST_METHOD:
case PW_DIGEST_URI:
case PW_DIGEST_QOP:
case PW_DIGEST_ALGORITHM:
case PW_DIGEST_BODY_DIGEST:
case PW_DIGEST_CNONCE:
case PW_DIGEST_NONCE_COUNT:
case PW_DIGEST_USER_NAME:
/* overlapping! */
memmove(&vp->strvalue[2], &vp->strvalue[0], vp->length);
vp->strvalue[0] = vp->attribute - PW_DIGEST_REALM + 1;
vp->length += 2;
vp->strvalue[1] = vp->length;
vp->attribute = PW_DIGEST_ATTRIBUTES;
break;
}
} /* loop over the VP's we read in */
if (!start)
{
start = radclient;
prev = start;
}
else
{
prev->next = radclient;
radclient->prev = prev;
prev = radclient;
}
/*
* And we're done.
*/
return radclient;
}
/*
* Compare two RADIUS_PACKET data structures, based on a number
* of criteria.
*/
static int send_one_packet(radclient_t *radclient)
{
int i;
assert(radclient->done == 0);
/*
* Remember when we have to wake up, to re-send the
* request, of we didn't receive a response.
*/
if ((sleep_time == -1) ||
(sleep_time > (int) timeout))
{
sleep_time = (int) timeout;
}
/*
* Haven't sent the packet yet. Initialize it.
*/
if (radclient->request->id == -1)
{
int found = 0;
assert(radclient->reply == NULL);
/*
* Find a free packet Id
*/
for (i = 0; i < 256; i++)
{
if (radius_id[(last_used_id + i) & 0xff] == 0)
{
last_used_id = (last_used_id + i) & 0xff;
radius_id[last_used_id] = 1;
radclient->request->id = last_used_id++;
found = 1;
break;
}
}
/*
* Didn't find a free packet ID, we're not done,
* we don't sleep, and we stop trying to process
* this packet.
*/
if (!found)
{
done = 0;
sleep_time = 0;
return 0;
}
assert(radclient->request->id != -1);
assert(radclient->request->data == NULL);
librad_md5_calc(radclient->request->vector, radclient->request->vector,
sizeof(radclient->request->vector));
/*
* Update the password, so it can be encrypted with the
* new authentication vector.
*/
if (radclient->password[0] != '\0')
{
VALUE_PAIR *vp;
if ((vp = pairfind(radclient->request->vps, PW_PASSWORD)) != NULL)
{
strNcpy((char *)vp->strvalue, radclient->password, sizeof(vp->strvalue));
vp->length = strlen(vp->strvalue);
}
else if ((vp = pairfind(radclient->request->vps, PW_CHAP_PASSWORD)) != NULL)
{
strNcpy((char *)vp->strvalue, radclient->password, sizeof(vp->strvalue));
vp->length = strlen(vp->strvalue);
rad_chap_encode(radclient->request, (char *) vp->strvalue, radclient->request->id, vp);
vp->length = 17;
}
}
radclient->timestamp = time(NULL);
radclient->tries = 1;
radclient->resend++;
/*
* Duplicate found. Serious error!
*/
}
else /* radclient->request->id >= 0 */
{
time_t now = time(NULL);
/*
* FIXME: Accounting packets are never retried!
* The Acct-Delay-Time attribute is updated to
* reflect the delay, and the packet is re-sent
* from scratch!
*/
/*
* Not time for a retry, do so.
*/
if ((now - radclient->timestamp) < timeout)
{
/*
* When we walk over the tree sending
* packets, we update the minimum time
* required to sleep.
*/
if ((sleep_time == -1) ||
(sleep_time > (now - radclient->timestamp)))
{
sleep_time = now - radclient->timestamp;
}
return 0;
}
/*
* We're not trying later, maybe the packet is done.
*/
if (radclient->tries == retries)
{
assert(radclient->request->id >= 0);
/*
* Delete the request from the tree of
* outstanding requests.
*/
fprintf(stderr, "radclient: no response from server for ID %d\n", radclient->request->id);
/*
* Normally we mark it "done" when we've received
* the response, but this is a special case.
*/
if (radclient->resend == resend_count)
{
radclient->done = 1;
}
totallost++;
return -1;
}
/*
* We are trying later.
*/
radclient->timestamp = now;
radclient->tries++;
}
/*
* Send the packet.
*/
if (rad_send(radclient->request, NULL, secret) < 0)
{
fprintf(stderr, "radclient: Failed to send packet for ID %d: %s\n",
radclient->request->id, librad_errstr);
}
return 0;
}
static int do_packet(int allports, uint32_t nasaddr, const struct radutmp *u)
{
int i, retries=5, timeout=3;
struct timeval tv;
RADIUS_PACKET *req, *rep = NULL;
VALUE_PAIR *vp;
const char *secret;
if ((req = rad_alloc(1)) == NULL) {
librad_perror("radzap");
exit(1);
}
req->id = getpid() & 0xFF;
req->code = PW_ACCOUNTING_REQUEST;
req->dst_port = acct_port;
if(req->dst_port == 0)
req->dst_port = getport("radacct");
if(req->dst_port == 0)
req->dst_port = PW_ACCT_UDP_PORT;
if (radiusip == INADDR_NONE) {
req->dst_ipaddr = ip_getaddr("localhost");
}
else {
req->dst_ipaddr = radiusip;
}
if(!req->dst_ipaddr)
req->dst_ipaddr = 0x7f000001;
req->vps = NULL;
secret = getsecret(req->dst_ipaddr);
if(allports != 0) {
INTPAIR(PW_ACCT_STATUS_TYPE, PW_STATUS_ACCOUNTING_OFF);
IPPAIR(PW_NAS_IP_ADDRESS, nasaddr);
INTPAIR(PW_ACCT_DELAY_TIME, 0);
} else {
char login[sizeof u->login+1];
char session_id[sizeof u->session_id+1];
strNcpy(login, u->login, sizeof login);
strNcpy(session_id, u->session_id, sizeof session_id);
INTPAIR(PW_ACCT_STATUS_TYPE, PW_STATUS_STOP);
IPPAIR(PW_NAS_IP_ADDRESS, u->nas_address);
INTPAIR(PW_ACCT_DELAY_TIME, 0);
STRINGPAIR(PW_USER_NAME, login);
INTPAIR(PW_NAS_PORT, u->nas_port);
STRINGPAIR(PW_ACCT_SESSION_ID, session_id);
if(u->proto=='P') {
INTPAIR(PW_SERVICE_TYPE, PW_FRAMED_USER);
INTPAIR(PW_FRAMED_PROTOCOL, PW_PPP);
} else if(u->proto=='S') {
INTPAIR(PW_SERVICE_TYPE, PW_FRAMED_USER);
INTPAIR(PW_FRAMED_PROTOCOL, PW_SLIP);
} else {
INTPAIR(PW_SERVICE_TYPE, PW_LOGIN_USER); /* A guess, really */
}
IPPAIR(PW_FRAMED_IP_ADDRESS, u->framed_address);
INTPAIR(PW_ACCT_SESSION_TIME, 0);
INTPAIR(PW_ACCT_INPUT_OCTETS, 0);
INTPAIR(PW_ACCT_OUTPUT_OCTETS, 0);
INTPAIR(PW_ACCT_INPUT_PACKETS, 0);
INTPAIR(PW_ACCT_OUTPUT_PACKETS, 0);
}
if ((req->sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("radzap: socket: ");
exit(1);
}
for (i = 0; i < retries; i++) {
fd_set rdfdesc;
rad_send(req, NULL, secret);
/* And wait for reply, timing out as necessary */
FD_ZERO(&rdfdesc);
FD_SET(req->sockfd, &rdfdesc);
tv.tv_sec = (int)timeout;
tv.tv_usec = 1000000 * (timeout - (int)timeout);
/* Something's wrong if we don't get exactly one fd. */
if (select(req->sockfd + 1, &rdfdesc, NULL, NULL, &tv) != 1) {
continue;
}
rep = rad_recv(req->sockfd);
if (rep != NULL) {
break;
} else { /* NULL: couldn't receive the packet */
librad_perror("radzap:");
exit(1);
}
}
/* No response or no data read (?) */
if (i == retries) {
fprintf(stderr, "%s: no response from server\n", progname);
exit(1);
}
if (rad_decode(rep, req, secret) != 0) {
librad_perror("rad_decode");
exit(1);
}
vp_printlist(stdout, rep->vps);
return 0;
}
