void ITransferObj::OnTransferRequest(ERequestSource eReqFrom, SapConnection_ptr ptrConn, const void *pBuffer, int nLen,const void*pExhead, int nExlen)
{
SSapMsgHeader *pHead=(SSapMsgHeader *)pBuffer;
unsigned int dwOldSeq=pHead->dwSequence;
unsigned int dwNewSeq=m_seq++;
pHead->dwSequence=dwNewSeq;
SPeerSeqPtr & s=m_SocSeqPtr[dwNewSeq];
s.dwSeq=dwOldSeq;
s.ptrConn=ptrConn;
s.dwServiceId = ntohl(pHead->dwServiceId);
s.dwMsgId = ntohl(pHead->dwMsgId);
s.eReqSource = eReqFrom;
//s.pCSObj = NULL;
s.sInfo = GetRequestInfo(pBuffer,nLen);
s.strAddr = GetIpAddr(pBuffer,nLen,pExhead,nExlen);
m_pManager->GetLogTrigger()->BeginTrigger(pBuffer,nLen,s.sLog);
m_pManager->gettimeofday(&(s.tmReceived), false);
s.ullTimeout = s.tmReceived.tv_sec * 1000LL + s.tmReceived.tv_usec / 1000;
s.ullTimeout += ASC_TIMEOUT_INTERVAL * 1000;
m_TimeList.insert(make_pair(s.ullTimeout, dwNewSeq));
SS_XLOG(XLOG_DEBUG,"ITransferObj::%s, seq[%u],buffer[%x],nlen[%d], rquest from[%d], old seq[%d]\n",
__FUNCTION__,dwNewSeq,pBuffer,nLen, eReqFrom, dwOldSeq);
WriteData(pBuffer,nLen, pExhead, nExlen);
}
int
nat_SetTarget(struct cmdargs const *arg)
{
struct in_addr addr;
if (arg->argc == arg->argn) {
addr.s_addr = INADDR_ANY;
LibAliasSetTarget(la, addr);
return 0;
}
if (arg->argc != arg->argn + 1)
return -1;
if (!strcasecmp(arg->argv[arg->argn], "MYADDR")) {
addr.s_addr = INADDR_ANY;
LibAliasSetTarget(la, addr);
return 0;
}
addr = GetIpAddr(arg->argv[arg->argn]);
if (addr.s_addr == INADDR_NONE) {
log_Printf(LogWARN, "%s: invalid address\n", arg->argv[arg->argn]);
return 1;
}
LibAliasSetTarget(la, addr);
return 0;
}
int ITransferObj::OnTransferAVSRequest(SapConnection_ptr ptrConn, const void *pBuffer, int nLen)
{
SSapMsgHeader *pHead=(SSapMsgHeader *)pBuffer;
unsigned int dwOldSeq=pHead->dwSequence;
unsigned int dwNewSeq=m_seq++;
pHead->dwSequence=dwNewSeq;
int nRet = WriteAvs(pBuffer,nLen);
if (nRet == 0)
{
SPeerSeqPtr & s=m_SocSeqPtr[dwNewSeq];
s.dwSeq=dwOldSeq;
s.dwServiceId = ntohl(pHead->dwServiceId);
s.dwMsgId = ntohl(pHead->dwMsgId);
s.eReqSource = SAP_Request_Remote;
s.ptrConn = ptrConn;
s.sInfo = GetRequestInfo(pBuffer,nLen);
s.strAddr = GetIpAddr(pBuffer,nLen,NULL,0);
m_pManager->gettimeofday(&(s.tmReceived), false);
s.ullTimeout = s.tmReceived.tv_sec * 1000LL + s.tmReceived.tv_usec / 1000;
s.ullTimeout += ASC_TIMEOUT_INTERVAL * 1000;
m_TimeList.insert(make_pair(s.ullTimeout, dwNewSeq));
m_pManager->GetLogTrigger()->BeginTrigger(pBuffer,nLen,s.sLog);
SS_XLOG(XLOG_DEBUG,"%s::%s, seq[%u], old seq[%d]\n",
m_strModule.c_str(),__FUNCTION__,dwNewSeq, dwOldSeq);
}
return nRet;
}
bool CFile::CheckHostIp(const char* sIpAddr)
{
uint32 nIp = GetIpAddr(sIpAddr);
if(nIp == (uint32)(-1))
return false;
return CheckHostIp(nIp);
}
static struct udpdevice *
udp_CreateDevice(struct physical *p, char *host, char *port)
{
struct udpdevice *dev;
struct servent *sp;
if ((dev = malloc(sizeof *dev)) == NULL) {
log_Printf(LogWARN, "%s: Cannot allocate a udp device: %s\n",
p->link.name, strerror(errno));
return NULL;
}
dev->sock.sin_family = AF_INET;
dev->sock.sin_addr = GetIpAddr(host);
if (dev->sock.sin_addr.s_addr == INADDR_NONE) {
log_Printf(LogWARN, "%s: %s: unknown host\n", p->link.name, host);
free(dev);
return NULL;
}
dev->sock.sin_port = htons(atoi(port));
if (dev->sock.sin_port == 0) {
sp = getservbyname(port, "udp");
if (sp)
dev->sock.sin_port = sp->s_port;
else {
log_Printf(LogWARN, "%s: %s: unknown service\n", p->link.name, port);
free(dev);
return NULL;
}
}
log_Printf(LogPHASE, "%s: Connecting to %s:%s/udp\n", p->link.name,
host, port);
p->fd = socket(PF_INET, SOCK_DGRAM, 0);
if (p->fd >= 0) {
log_Printf(LogDEBUG, "%s: Opened udp socket %s\n", p->link.name,
p->name.full);
if (connect(p->fd, (struct sockaddr *)&dev->sock, sizeof dev->sock) == 0) {
dev->connected = UDP_CONNECTED;
return dev;
} else
log_Printf(LogWARN, "%s: connect: %s\n", p->name.full, strerror(errno));
} else
log_Printf(LogWARN, "%s: socket: %s\n", p->name.full, strerror(errno));
close(p->fd);
p->fd = -1;
free(dev);
return NULL;
}
void
hcpInit()
{
host_rec *myrec;
hcp = (HelloConfp)malloc(sizeof(HelloConf));
/* Hello Protocol Initialization */
time(&hcp->start_time);
hcp->HPeriod = hello_interval;
hcp->DeadInt = hello_interval * hello_dead_factor;
hcp->nsm_list = listInit();
hcp->curmsg.pktp = NULL;
hcp->curmsg.sa = malloc(sizeof(struct sockaddr_in));
hcp->hrecs = listInit();
myrec = (host_rec *)malloc(sizeof(host_rec));
myrec->host = GetIpAddr(hello_ifname);
myrec->primary = htonl(0);
Pthread_mutex_lock(&(host_dbrev.mutex));
myrec->prio.dbrev = htonl(host_dbrev.value);
Pthread_mutex_unlock(&(host_dbrev.mutex));
myrec->prio.group = htons(hello_group);
myrec->prio.self = htons(hello_priority);
myrec->prio.start_time_c = htonl(~(hcp->start_time));
myrec->HPeriod = htonl(hello_interval);
myrec->DeadInt = htonl(hello_interval*hello_dead_factor);
listAddItem(hcp->hrecs, myrec);
hcp->reg = Malloc(sizeof(default_reg));
hcp->state = HSM_STATE_DOWN;
memcpy(hcp->reg, &default_reg, sizeof(default_reg));
NetFdsInit(&(hcp->nfs));
HelloCreateLocks();
hcp->lockid = 0;
// LockGetLock(hcp_lock, 0, 0);
hcp->pri_sa = NULL;
// LockReleaseLock(hcp_lock);
qInit(&hcp->eventq, HELLO_EVENT_SIZE, HELLO_EVENTQ_LEN);
}
static int
tcp_OpenConnection(const char *name, char *host, char *port)
{
struct sockaddr_in dest;
int sock;
struct servent *sp;
dest.sin_family = AF_INET;
dest.sin_addr = GetIpAddr(host);
if (dest.sin_addr.s_addr == INADDR_NONE) {
log_Printf(LogWARN, "%s: %s: unknown host\n", name, host);
return -2;
}
dest.sin_port = htons(atoi(port));
if (dest.sin_port == 0) {
sp = getservbyname(port, "tcp");
if (sp)
dest.sin_port = sp->s_port;
else {
log_Printf(LogWARN, "%s: %s: unknown service\n", name, port);
return -2;
}
}
log_Printf(LogPHASE, "%s: Connecting to %s:%s/tcp\n", name, host, port);
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock < 0)
return -2;
if (connect(sock, (struct sockaddr *)&dest, sizeof dest) < 0) {
log_Printf(LogWARN, "%s: connect: %s\n", name, strerror(errno));
close(sock);
return -2;
}
return sock;
}
void ITransferObj::OnTransferMapQRequest(void *pExBuffer, int nExLen)
{
SForwardMsg *pForwardMsg = (SForwardMsg*)pExBuffer;
int nLen = nExLen - sizeof(SForwardMsg);
SSapMsgHeader *pHead = (SSapMsgHeader *)(pForwardMsg->pBuffer);
unsigned int dwOldSeq = pHead->dwSequence;
unsigned int dwNewSeq = m_seq++;
pHead->dwSequence=dwNewSeq;
SPeerSeqPtr & s=m_SocSeqPtr[dwNewSeq];
s.dwSeq=dwOldSeq;
s.dwServiceId = ntohl(pHead->dwServiceId);
s.dwMsgId = ntohl(pHead->dwMsgId);
s.eReqSource = SAP_Request_MapQ;
//s.pCSObj = NULL;
s.sAckInfo.bAckMsg = true;
s.sAckInfo.pExBuffer = pExBuffer;
s.sAckInfo.nExLen = nExLen;
s.strAddr = GetIpAddr(pForwardMsg->pBuffer,nLen,NULL,0);
s.sCompose.dwServiceId = pForwardMsg->dwComposeSrvId;
s.sCompose.dwMsgId = pForwardMsg->dwComposeMsgId;
//s.dwOriginalSeq = pForwardMsg->dwOriginalSeq;
s.sInfo = GetRequestInfo(pForwardMsg->pBuffer,nLen);
m_pManager->gettimeofday(&(s.tmReceived), false);
s.ullTimeout = s.tmReceived.tv_sec * 1000LL + s.tmReceived.tv_usec / 1000;
s.ullTimeout += ASC_TIMEOUT_INTERVAL * 1000;
m_TimeList.insert(make_pair(s.ullTimeout, dwNewSeq));
SS_XLOG(XLOG_DEBUG,"%s::%s, seq[%u],buffer[%x],nlen[%d], rquest from[%d], old seq[%d]\n",
m_strModule.c_str(),__FUNCTION__,dwNewSeq,pExBuffer,nExLen, SAP_Request_MapQ, dwOldSeq);
//((CSessionManager *)m_pManager)->m_oReportData.dwRequest++;
WriteData(pForwardMsg->pBuffer,nLen);
}
REQUEST_NOTIFICATION_STATUS
CMyHttpModule::OnBeginRequest(
IN IHttpContext * pHttpContext,
IN IHttpEventProvider * pProvider
)
{
HRESULT hr = S_OK;
IHttpRequest* pRequest = NULL;
MODSECURITY_STORED_CONTEXT* pConfig = NULL;
UNREFERENCED_PARAMETER ( pProvider );
EnterCriticalSection(&m_csLock);
if ( pHttpContext == NULL )
{
hr = E_UNEXPECTED;
goto Finished;
}
pRequest = pHttpContext->GetRequest();
if ( pRequest == NULL )
{
hr = E_UNEXPECTED;
goto Finished;
}
hr = MODSECURITY_STORED_CONTEXT::GetConfig(pHttpContext, &pConfig );
if ( FAILED( hr ) )
{
//hr = E_UNEXPECTED;
hr = S_OK;
goto Finished;
}
// If module is disabled, dont go any further
//
if( pConfig->GetIsEnabled() == false )
{
goto Finished;
}
// every 3 seconds we check for changes in config file
//
DWORD ctime = GetTickCount();
if(pConfig->m_Config == NULL || (ctime - pConfig->m_dwLastCheck) > 3000)
{
char *path;
USHORT pathlen;
hr = pConfig->GlobalWideCharToMultiByte(pConfig->GetPath(), wcslen(pConfig->GetPath()), &path, &pathlen);
if ( FAILED( hr ) )
{
hr = E_UNEXPECTED;
goto Finished;
}
WIN32_FILE_ATTRIBUTE_DATA fdata;
BOOL ret;
ret = GetFileAttributesEx(path, GetFileExInfoStandard, &fdata);
pConfig->m_dwLastCheck = ctime;
if(pConfig->m_Config == NULL || (ret != 0 && (pConfig->m_LastChange.dwLowDateTime != fdata.ftLastWriteTime.dwLowDateTime ||
pConfig->m_LastChange.dwHighDateTime != fdata.ftLastWriteTime.dwHighDateTime)))
{
pConfig->m_LastChange.dwLowDateTime = fdata.ftLastWriteTime.dwLowDateTime;
pConfig->m_LastChange.dwHighDateTime = fdata.ftLastWriteTime.dwHighDateTime;
pConfig->m_Config = modsecGetDefaultConfig();
PCWSTR servpath = pHttpContext->GetApplication()->GetApplicationPhysicalPath();
char *apppath;
USHORT apppathlen;
hr = pConfig->GlobalWideCharToMultiByte((WCHAR *)servpath, wcslen(servpath), &apppath, &apppathlen);
if ( FAILED( hr ) )
{
delete path;
hr = E_UNEXPECTED;
goto Finished;
}
if(path[0] != 0)
{
const char * err = modsecProcessConfig((directory_config *)pConfig->m_Config, path, apppath);
if(err != NULL)
{
WriteEventViewerLog(err, EVENTLOG_ERROR_TYPE);
delete apppath;
delete path;
goto Finished;
}
}
delete apppath;
}
delete path;
}
conn_rec *c;
request_rec *r;
c = modsecNewConnection();
modsecProcessConnection(c);
r = modsecNewRequest(c, (directory_config *)pConfig->m_Config);
// on IIS we force input stream inspection flag, because its absence does not add any performance gain
// it's because on IIS request body must be restored each time it was read
//
modsecSetConfigForIISRequestBody(r);
REQUEST_STORED_CONTEXT *rsc = new REQUEST_STORED_CONTEXT();
rsc->m_pConnRec = c;
rsc->m_pRequestRec = r;
rsc->m_pHttpContext = pHttpContext;
rsc->m_pProvider = pProvider;
pHttpContext->GetModuleContextContainer()->SetModuleContext(rsc, g_pModuleContext);
StoreIISContext(r, rsc);
HTTP_REQUEST *req = pRequest->GetRawHttpRequest();
r->hostname = ConvertUTF16ToUTF8(req->CookedUrl.pHost, req->CookedUrl.HostLength / sizeof(WCHAR), r->pool);
r->path_info = ConvertUTF16ToUTF8(req->CookedUrl.pAbsPath, req->CookedUrl.AbsPathLength / sizeof(WCHAR), r->pool);
if(r->hostname == NULL)
{
if(req->Headers.KnownHeaders[HttpHeaderHost].pRawValue != NULL)
r->hostname = ZeroTerminate(req->Headers.KnownHeaders[HttpHeaderHost].pRawValue,
req->Headers.KnownHeaders[HttpHeaderHost].RawValueLength, r->pool);
}
int port = 0;
char *port_str = NULL;
if(r->hostname != NULL)
{
int k = 0;
char *ptr = (char *)r->hostname;
while(*ptr != 0 && *ptr != ':')
ptr++;
if(*ptr == ':')
{
*ptr = 0;
port_str = ptr + 1;
port = atoi(port_str);
}
}
if(req->CookedUrl.pQueryString != NULL && req->CookedUrl.QueryStringLength > 0)
r->args = ConvertUTF16ToUTF8(req->CookedUrl.pQueryString + 1, (req->CookedUrl.QueryStringLength / sizeof(WCHAR)) - 1, r->pool);
#define _TRANSHEADER(id,str) if(req->Headers.KnownHeaders[id].pRawValue != NULL) \
{\
apr_table_setn(r->headers_in, str, \
ZeroTerminate(req->Headers.KnownHeaders[id].pRawValue, req->Headers.KnownHeaders[id].RawValueLength, r->pool)); \
}
_TRANSHEADER(HttpHeaderCacheControl, "Cache-Control");
_TRANSHEADER(HttpHeaderConnection, "Connection");
_TRANSHEADER(HttpHeaderDate, "Date");
_TRANSHEADER(HttpHeaderKeepAlive, "Keep-Alive");
_TRANSHEADER(HttpHeaderPragma, "Pragma");
_TRANSHEADER(HttpHeaderTrailer, "Trailer");
_TRANSHEADER(HttpHeaderTransferEncoding, "Transfer-Encoding");
_TRANSHEADER(HttpHeaderUpgrade, "Upgrade");
_TRANSHEADER(HttpHeaderVia, "Via");
_TRANSHEADER(HttpHeaderWarning, "Warning");
_TRANSHEADER(HttpHeaderAllow, "Allow");
_TRANSHEADER(HttpHeaderContentLength, "Content-Length");
_TRANSHEADER(HttpHeaderContentType, "Content-Type");
_TRANSHEADER(HttpHeaderContentEncoding, "Content-Encoding");
_TRANSHEADER(HttpHeaderContentLanguage, "Content-Language");
_TRANSHEADER(HttpHeaderContentLocation, "Content-Location");
_TRANSHEADER(HttpHeaderContentMd5, "Content-Md5");
_TRANSHEADER(HttpHeaderContentRange, "Content-Range");
_TRANSHEADER(HttpHeaderExpires, "Expires");
_TRANSHEADER(HttpHeaderLastModified, "Last-Modified");
_TRANSHEADER(HttpHeaderAccept, "Accept");
_TRANSHEADER(HttpHeaderAcceptCharset, "Accept-Charset");
_TRANSHEADER(HttpHeaderAcceptEncoding, "Accept-Encoding");
_TRANSHEADER(HttpHeaderAcceptLanguage, "Accept-Language");
_TRANSHEADER(HttpHeaderAuthorization, "Authorization");
_TRANSHEADER(HttpHeaderCookie, "Cookie");
_TRANSHEADER(HttpHeaderExpect, "Expect");
_TRANSHEADER(HttpHeaderFrom, "From");
_TRANSHEADER(HttpHeaderHost, "Host");
_TRANSHEADER(HttpHeaderIfMatch, "If-Match");
_TRANSHEADER(HttpHeaderIfModifiedSince, "If-Modified-Since");
_TRANSHEADER(HttpHeaderIfNoneMatch, "If-None-Match");
_TRANSHEADER(HttpHeaderIfRange, "If-Range");
_TRANSHEADER(HttpHeaderIfUnmodifiedSince, "If-Unmodified-Since");
_TRANSHEADER(HttpHeaderMaxForwards, "Max-Forwards");
_TRANSHEADER(HttpHeaderProxyAuthorization, "Proxy-Authorization");
_TRANSHEADER(HttpHeaderReferer, "Referer");
_TRANSHEADER(HttpHeaderRange, "Range");
_TRANSHEADER(HttpHeaderTe, "TE");
_TRANSHEADER(HttpHeaderTranslate, "Translate");
_TRANSHEADER(HttpHeaderUserAgent, "User-Agent");
#undef _TRANSHEADER
for(int i = 0; i < req->Headers.UnknownHeaderCount; i++)
{
apr_table_setn(r->headers_in,
ZeroTerminate(req->Headers.pUnknownHeaders[i].pName, req->Headers.pUnknownHeaders[i].NameLength, r->pool),
ZeroTerminate(req->Headers.pUnknownHeaders[i].pRawValue, req->Headers.pUnknownHeaders[i].RawValueLength, r->pool));
}
r->content_encoding = apr_table_get(r->headers_in, "Content-Encoding");
r->content_type = apr_table_get(r->headers_in, "Content-Type");
const char *lng = apr_table_get(r->headers_in, "Content-Languages");
if(lng != NULL)
{
r->content_languages = apr_array_make(r->pool, 1, sizeof(const char *));
*(const char **)apr_array_push(r->content_languages) = lng;
}
switch(req->Verb)
{
case HttpVerbUnparsed:
case HttpVerbUnknown:
case HttpVerbInvalid:
case HttpVerbTRACK: // used by Microsoft Cluster Server for a non-logged trace
case HttpVerbSEARCH:
default:
r->method = "INVALID";
r->method_number = M_INVALID;
break;
case HttpVerbOPTIONS:
r->method = "OPTIONS";
r->method_number = M_OPTIONS;
break;
case HttpVerbGET:
case HttpVerbHEAD:
r->method = "GET";
r->method_number = M_GET;
break;
case HttpVerbPOST:
r->method = "POST";
r->method_number = M_POST;
break;
case HttpVerbPUT:
r->method = "PUT";
r->method_number = M_PUT;
break;
case HttpVerbDELETE:
r->method = "DELETE";
r->method_number = M_DELETE;
break;
case HttpVerbTRACE:
r->method = "TRACE";
r->method_number = M_TRACE;
break;
case HttpVerbCONNECT:
r->method = "CONNECT";
r->method_number = M_CONNECT;
break;
case HttpVerbMOVE:
r->method = "MOVE";
r->method_number = M_MOVE;
break;
case HttpVerbCOPY:
r->method = "COPY";
r->method_number = M_COPY;
break;
case HttpVerbPROPFIND:
r->method = "PROPFIND";
r->method_number = M_PROPFIND;
break;
case HttpVerbPROPPATCH:
r->method = "PROPPATCH";
r->method_number = M_PROPPATCH;
break;
case HttpVerbMKCOL:
r->method = "MKCOL";
r->method_number = M_MKCOL;
break;
case HttpVerbLOCK:
r->method = "LOCK";
r->method_number = M_LOCK;
break;
case HttpVerbUNLOCK:
r->method = "UNLOCK";
r->method_number = M_UNLOCK;
break;
}
if(HTTP_EQUAL_VERSION(req->Version, 0, 9))
r->protocol = "HTTP/0.9";
else if(HTTP_EQUAL_VERSION(req->Version, 1, 0))
r->protocol = "HTTP/1.0";
else
r->protocol = "HTTP/1.1";
r->request_time = apr_time_now();
r->parsed_uri.scheme = "http";
r->parsed_uri.path = r->path_info;
r->parsed_uri.hostname = (char *)r->hostname;
r->parsed_uri.is_initialized = 1;
r->parsed_uri.port = port;
r->parsed_uri.port_str = port_str;
r->parsed_uri.query = r->args;
r->parsed_uri.dns_looked_up = 0;
r->parsed_uri.dns_resolved = 0;
r->parsed_uri.password = NULL;
r->parsed_uri.user = NULL;
r->parsed_uri.fragment = NULL;
r->unparsed_uri = ZeroTerminate(req->pRawUrl, req->RawUrlLength, r->pool);
r->uri = r->unparsed_uri;
r->the_request = (char *)apr_palloc(r->pool, strlen(r->method) + 1 + req->RawUrlLength + 1 + strlen(r->protocol) + 1);
strcpy(r->the_request, r->method);
strcat(r->the_request, " ");
strcat(r->the_request, r->uri);
strcat(r->the_request, " ");
strcat(r->the_request, r->protocol);
HTTP_REQUEST_ID httpRequestID;
char *pszValue = (char *)apr_palloc(r->pool, 24);
httpRequestID = pRequest->GetRawHttpRequest()->RequestId;
_ui64toa(httpRequestID, pszValue, 10);
apr_table_setn(r->subprocess_env, "UNIQUE_ID", pszValue);
PSOCKADDR pAddr = pRequest->GetRemoteAddress();
#if AP_SERVER_MAJORVERSION_NUMBER > 1 && AP_SERVER_MINORVERSION_NUMBER < 3
c->remote_addr = CopySockAddr(r->pool, pAddr);
c->remote_ip = GetIpAddr(r->pool, pAddr);
#else
c->client_addr = CopySockAddr(r->pool, pAddr);
c->client_ip = GetIpAddr(r->pool, pAddr);
#endif
c->remote_host = NULL;
int status = modsecProcessRequest(r);
if(status != DECLINED)
{
pHttpContext->GetResponse()->SetStatus(status, "ModSecurity Action");
pHttpContext->SetRequestHandled();
hr = E_FAIL;
goto Finished;
}
Finished:
LeaveCriticalSection(&m_csLock);
if ( FAILED( hr ) )
{
return RQ_NOTIFICATION_FINISH_REQUEST;
}
return RQ_NOTIFICATION_CONTINUE;
}
int
ncprange_aton(struct ncprange *range, struct ncp *ncp, const char *data)
{
int bits, len;
char *wp;
const char *cp;
char *s;
len = strcspn(data, "/");
if (ncp && strncasecmp(data, "HISADDR", len) == 0) {
range->ncprange_family = AF_INET;
range->ncprange_ip4addr = ncp->ipcp.peer_ip;
range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
range->ncprange_ip4width = 32;
return 1;
#ifndef NOINET6
} else if (ncp && strncasecmp(data, "HISADDR6", len) == 0) {
range->ncprange_family = AF_INET6;
range->ncprange_ip6addr = ncp->ipv6cp.hisaddr.ncpaddr_ip6addr;
range->ncprange_ip6width = 128;
return 1;
#endif
} else if (ncp && strncasecmp(data, "MYADDR", len) == 0) {
range->ncprange_family = AF_INET;
range->ncprange_ip4addr = ncp->ipcp.my_ip;
range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
range->ncprange_ip4width = 32;
return 1;
#ifndef NOINET6
} else if (ncp && strncasecmp(data, "MYADDR6", len) == 0) {
range->ncprange_family = AF_INET6;
range->ncprange_ip6addr = ncp->ipv6cp.myaddr.ncpaddr_ip6addr;
range->ncprange_ip6width = 128;
return 1;
#endif
} else if (ncp && strncasecmp(data, "DNS0", len) == 0) {
range->ncprange_family = AF_INET;
range->ncprange_ip4addr = ncp->ipcp.ns.dns[0];
range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
range->ncprange_ip4width = 32;
return 1;
} else if (ncp && strncasecmp(data, "DNS1", len) == 0) {
range->ncprange_family = AF_INET;
range->ncprange_ip4addr = ncp->ipcp.ns.dns[1];
range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
range->ncprange_ip4width = 32;
return 1;
}
s = (char *)alloca(len + 1);
strncpy(s, data, len);
s[len] = '\0';
bits = -1;
if (data[len] != '\0') {
bits = strtol(data + len + 1, &wp, 0);
if (*wp || wp == data + len + 1 || bits < 0 || bits > 128) {
log_Printf(LogWARN, "ncprange_aton: bad mask width.\n");
return 0;
}
}
if ((cp = strchr(data, ':')) == NULL) {
range->ncprange_family = AF_INET;
range->ncprange_ip4addr = GetIpAddr(s);
if (range->ncprange_ip4addr.s_addr == INADDR_NONE) {
log_Printf(LogWARN, "ncprange_aton: %s: Bad address\n", s);
return 0;
}
if (range->ncprange_ip4addr.s_addr == INADDR_ANY) {
range->ncprange_ip4mask.s_addr = INADDR_ANY;
range->ncprange_ip4width = 0;
} else if (bits == -1) {
range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
range->ncprange_ip4width = 32;
} else if (bits > 32) {
log_Printf(LogWARN, "ncprange_aton: bad mask width.\n");
return 0;
} else {
range->ncprange_ip4mask = bits2mask4(bits);
range->ncprange_ip4width = bits;
}
return 1;
#ifndef NOINET6
} else if (strchr(cp + 1, ':') != NULL) {
range->ncprange_family = AF_INET6;
if (inet_pton(AF_INET6, s, &range->ncprange_ip6addr) != 1) {
log_Printf(LogWARN, "ncprange_aton: %s: Bad address\n", s);
return 0;
}
if (IN6_IS_ADDR_UNSPECIFIED(&range->ncprange_ip6addr))
range->ncprange_ip6width = 0;
else
range->ncprange_ip6width = (bits == -1) ? 128 : bits;
return 1;
#endif
}
return 0;
}
