int main(int argc, char **argv)
{
const char *options="c:i:";
int opt_status=0;
int pppoe_count=1;
char *NIC_name;
while((opt_status=getopt(argc,argv,options))!=-1)
switch (opt_status) {
case 'c':
pppoe_count=atoi(optarg);
break;
case 'i':
NIC_name=optarg;
break;
default:
break;
}
//how many pppoe client to fork is determined!
struct Connection_info infos[pppoe_count];
memset(infos,0,sizeof(infos));
//shuttles for pppoe infomations
srand((unsigned int)getpid()); //ready for rand
set_promisc(NIC_name); //set the NIC to be used promisc mode
int count1;
for(count1=0;count1<pppoe_count;++count1) {
infos[count1].ifindex=get_ifindex(NIC_name); //get the ifindex of NIC
infos[count1].my_mac[0]=0x11;
infos[count1].my_mac[1]=0x22;
infos[count1].my_mac[2]=0x33;
int loop_count;
for(loop_count=3;loop_count<6;++loop_count) {
infos[count1].my_mac[loop_count]=(int)(rand()/(float)RAND_MAX*255);
}
//src mac of package done!
infos[count1].discovery_sock=socket(AF_PACKET,SOCK_RAW,htons(ETHER_TYPE_DISCOVERY));
if(infos[count1].discovery_sock<0) {
printf("error in creating discovery socket\n%s\n",strerror(errno));
exit(1);
}
//discovery socket's ready!
sendPADI(&infos[count1]);
recv_PADO(&infos[count1]);
sendPADR(&infos[count1]);
recv_PADS(&infos[count1]);
if(fork()==0) {
session(&infos[count1]);
}
printf("client %i is forked!\n",count1+1);
sleep(1);
}
return 0;
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts = 0;
int padrAttempts = 0;
int timeout = conn->discoveryTimeout;
conn->discoverySocket =
openInterface(conn->ifName, Eth_PPPOE_Discovery, conn->myEth);
do {
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS) {
printErr("Timeout waiting for PADO packets");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
timeout *= 3;
if (timeout > 60)
timeout = 10;
} while (conn->discoveryState == STATE_SENT_PADI);
timeout = conn->discoveryTimeout;
do {
padrAttempts++;
if (padrAttempts > MAX_PADI_ATTEMPTS) {
printErr("Timeout waiting for PADS packets");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
timeout *= 3;
if (timeout > 60)
timeout = 10;
} while (conn->discoveryState == STATE_SENT_PADR);
if (!conn->seenMaxPayload) {
/* RFC 4638: MUST limit MTU/MRU to 1492 */
if (lcp_allowoptions[0].mru > ETH_PPPOE_MTU)
lcp_allowoptions[0].mru = ETH_PPPOE_MTU;
if (lcp_wantoptions[0].mru > ETH_PPPOE_MTU)
lcp_wantoptions[0].mru = ETH_PPPOE_MTU;
}
/* We're done. */
conn->discoveryState = STATE_SESSION;
return;
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts = 0;
int padrAttempts = 0;
int timeout = conn->discoveryTimeout;
do {
padiAttempts++;
if (padiAttempts > conn->discoveryAttempts) {
warn("Timeout waiting for PADO packets");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADI);
timeout = conn->discoveryTimeout;
do {
padrAttempts++;
if (padrAttempts > conn->discoveryAttempts) {
warn("Timeout waiting for PADS packets");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADR);
if (!conn->seenMaxPayload) {
/* RFC 4638: MUST limit MTU/MRU to 1492 */
if (lcp_allowoptions[0].mru > ETH_PPPOE_MTU)
lcp_allowoptions[0].mru = ETH_PPPOE_MTU;
if (lcp_wantoptions[0].mru > ETH_PPPOE_MTU)
lcp_wantoptions[0].mru = ETH_PPPOE_MTU;
}
/* We're done. */
conn->discoveryState = STATE_SESSION;
return;
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts = 0;
int padrAttempts = 0;
int timeout = conn->discoveryTimeout;
conn->discoverySocket =
openInterface(conn->ifName, Eth_PPPOE_Discovery, conn->myEth);
do {
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS) {
warn("Timeout waiting for PADO packets");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADI);
timeout = conn->discoveryTimeout;
do {
padrAttempts++;
if (padrAttempts > MAX_PADI_ATTEMPTS) {
warn("Timeout waiting for PADS packets");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADR);
/* We're done. */
conn->discoveryState = STATE_SESSION;
return;
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts = 0;
int timeout = PADI_TIMEOUT;
conn->discoverySocket =
openInterface(conn->ifName, Eth_PPPOE_Discovery, conn->myEth);
do {
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS) {
fprintf(stderr, "Timeout waiting for PADO packets\n");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
} while (!conn->numPADOs);
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts = 0;
int padrAttempts = 0;
int timeout = PADI_TIMEOUT;
/* Skip discovery and don't open discovery socket? */
if (conn->skipDiscovery && conn->noDiscoverySocket) {
conn->discoveryState = STATE_SESSION;
return;
}
conn->discoverySocket =
openInterface(conn->ifName, Eth_PPPOE_Discovery, conn->myEth);
/* Skip discovery? */
if (conn->skipDiscovery) {
conn->discoveryState = STATE_SESSION;
if (conn->killSession) {
sendPADT(conn, "RP-PPPoE: Session killed manually");
exit(0);
}
return;
}
do {
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS) {
system("rm /etc/ppp/connectfile");
rp_fatal("Timeout waiting for PADO packets0");
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
#if 0 // RexHua to Reduce connect time
/* If we're just probing for access concentrators, don't do
exponential backoff. This reduces the time for an unsuccessful
probe to 15 seconds. */
if (!conn->printACNames) {
timeout *= 2;
}
#endif
if (conn->printACNames && conn->numPADOs) {
break;
}
} while (conn->discoveryState == STATE_SENT_PADI);
/* If we're only printing access concentrator names, we're done */
if (conn->printACNames) {
printf("--------------------------------------------------\n");
exit(0);
}
timeout = PADI_TIMEOUT;
do {
padrAttempts++;
if (padrAttempts > MAX_PADI_ATTEMPTS) {
rp_fatal("Timeout waiting for PADS packets");
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
#if 0 // RexHua to Reduce connect time
timeout *= 2;
#endif
} while (conn->discoveryState == STATE_SENT_PADR);
/* We're done. */
conn->discoveryState = STATE_SESSION;
return;
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts = 0;
int padrAttempts = 0;
int timeout = PADI_TIMEOUT;
/* Skip discovery and don't open discovery socket? */
if (conn->skipDiscovery && conn->noDiscoverySocket) {
conn->discoveryState = STATE_SESSION;
return;
}
conn->discoverySocket =
openInterface(conn->ifName, Eth_PPPOE_Discovery, conn->myEth);
/* Skip discovery? */
if (conn->skipDiscovery) {
conn->discoveryState = STATE_SESSION;
return;
}
do {
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS) {
warn("Timeout waiting for PADO packets");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
/* If we're just probing for access concentrators, don't do
exponential backoff. This reduces the time for an unsuccessful
probe to 15 seconds. */
if (!conn->printACNames) {
timeout *= 2;
}
if (conn->printACNames && conn->numPADOs) {
break;
}
} while (conn->discoveryState == STATE_SENT_PADI);
/* If we're only printing access concentrator names, we're done */
if (conn->printACNames) {
die(0);
}
timeout = PADI_TIMEOUT;
do {
padrAttempts++;
if (padrAttempts > MAX_PADI_ATTEMPTS) {
warn("Timeout waiting for PADS packets");
close(conn->discoverySocket);
conn->discoverySocket = -1;
return;
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADR);
/* We're done. */
conn->discoveryState = STATE_SESSION;
return;
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts = 0;
int padrAttempts = 0;
int timeout = conn->discoveryTimeout;
/* Skip discovery? */
if (conn->skipDiscovery) {
conn->discoveryState = STATE_SESSION;
if (conn->killSession) {
sendPADT(conn, "RP-PPPoE: Session killed manually");
exit(0);
}
return;
}
do {
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS) {
if (persist) {
padiAttempts = 0;
timeout = conn->discoveryTimeout;
printErr("Timeout waiting for PADO packets");
} else {
rp_fatal("Timeout waiting for PADO packets");
}
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
/* If we're just probing for access concentrators, don't do
exponential backoff. This reduces the time for an unsuccessful
probe to 15 seconds. */
if (!conn->printACNames) {
timeout *= 2;
}
if (conn->printACNames && conn->numPADOs) {
break;
}
} while (conn->discoveryState == STATE_SENT_PADI);
/* If we're only printing access concentrator names, we're done */
if (conn->printACNames) {
exit(0);
}
timeout = conn->discoveryTimeout;
do {
padrAttempts++;
if (padrAttempts > MAX_PADI_ATTEMPTS) {
if (persist) {
padrAttempts = 0;
timeout = conn->discoveryTimeout;
printErr("Timeout waiting for PADS packets");
} else {
rp_fatal("Timeout waiting for PADS packets");
}
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADR);
/* We're done. */
conn->discoveryState = STATE_SESSION;
return;
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts = 0;
int padrAttempts = 0;
int timeout = PADI_TIMEOUT;
/* Skip discovery and don't open discovery socket? */
if (conn->skipDiscovery && conn->noDiscoverySocket) {
conn->discoveryState = STATE_SESSION;
PPPD_DEBUG(printf("%s %d\n",__FILE__,__LINE__));
return;
}
conn->discoverySocket =
openInterface(conn->ifName, Eth_PPPOE_Discovery, conn->myEth);
/* Skip discovery? */
if (conn->skipDiscovery) {
conn->discoveryState = STATE_SESSION;
if (conn->killSession) {
sendPADT(conn, "RP-PPPoE: Session killed manually");
exit(0);
}
PPPD_DEBUG(printf("%s %d\n",__FILE__,__LINE__));
return;
}
do {
PPPD_DEBUG(printf("%s %d\n",__FILE__,__LINE__));
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS)
{
rp_fatal("Timeout waiting for PADO packets");
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
/* If we're just probing for access concentrators, don't do
exponential backoff. This reduces the time for an unsuccessful
probe to 15 seconds. */
if (!conn->printACNames) {
timeout *= 2;
}
if (conn->printACNames && conn->numPADOs) {
break;
}
} while (conn->discoveryState == STATE_SENT_PADI);
/* If we're only printing access concentrator names, we're done */
if (conn->printACNames) {
printf("--------------------------------------------------\n");
exit(0);
}
PPPD_DEBUG(printf("%s %d\n",__FILE__,__LINE__));
timeout = PADI_TIMEOUT;
do {
PPPD_DEBUG(printf("%s %d\n",__FILE__,__LINE__));
padrAttempts++;
if (padrAttempts > MAX_PADI_ATTEMPTS) {
rp_fatal("Timeout waiting for PADS packets");
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADR);
/* We're done. */
free(conn->serviceName);//mcli
conn->serviceName=NULL;//mcli
conn->discoveryState = STATE_SESSION;
PPPD_DEBUG(printf("%s %d\n",__FILE__,__LINE__));
return;
}
void kpppoe_discovery(PPPoEConnection * conn)
{
int padiAttempts = 0;
int padrAttempts = 0;
int timeout = PADI_TIMEOUT;
d_dbg("[%d]: kpppoe_discovery() >>>\n", getpid());
/* Skip discovery and don't open discovery socket ? */
if (conn->skipDiscovery && conn->noDiscoverySocket)
{
conn->discoveryState = STATE_SESSION;
return;
}
conn->discoverySocket =
openInterface(conn->ifName, Eth_PPPOE_Discovery, conn->myEth);
/* Skip discovery ? */
if (conn->skipDiscovery)
{
conn->discoveryState = STATE_SESSION;
if (conn->killSession)
{
kpppoe_sendPADT(conn, "Session killed manually");
exit(0);
}
return;
}
do
{
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS)
{
d_warn("[%d]: Timeout waiting for PADO packets\n", getpid());
return;
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
/* If we're just probing for access concentrators, don't do
* exponential backoff. This reduces the time for an unsuccessful
* probe to 15 seconds. */
if (!conn->printACNames) timeout *= 2;
if (conn->printACNames && conn->numPADOs) break;
} while (conn->discoveryState == STATE_SENT_PADI);
/* If we're only printing access concentrator names, we're done */
if (conn->printACNames)
{
printf("-----------------------------------------------------------\n");
exit(0);
}
timeout = PADI_TIMEOUT;
do
{
padrAttempts++;
if (padrAttempts > MAX_PADI_ATTEMPTS)
{
d_warn("[%d]: Timeout waiting for PADS packets, timeout=[%d]\n", getpid(), timeout);
return;
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADR);
/* We're done. */
conn->discoveryState = STATE_SESSION;
return;
}
/**********************************************************************
*%FUNCTION: discovery
*%ARGUMENTS:
* conn -- PPPoE connection info structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Performs the PPPoE discovery phase
***********************************************************************/
void
discovery(PPPoEConnection *conn)
{
int padiAttempts;
int padrAttempts;
int timeout = conn->discoveryTimeout;
/* Skip discovery? */
if (conn->skipDiscovery) {
conn->discoveryState = STATE_SESSION;
if (conn->killSession) {
sendPADT(conn, "RP-PPPoE: Session killed manually");
exit(0);
}
return;
}
SEND_PADI:
padiAttempts = 0;
do {
#ifdef PLUGIN
if (got_sigterm || got_sighup) return;
#endif
padiAttempts++;
if (padiAttempts > MAX_PADI_ATTEMPTS) {
if (persist) {
padiAttempts = 0;
timeout = conn->discoveryTimeout;
printErr("Timeout waiting for PADO packets");
} else {
#ifdef PLUGIN
printErr("Timeout waiting for PADO packets");
return;
#else
rp_fatal("Timeout waiting for PADO packets");
#endif
}
}
sendPADI(conn);
conn->discoveryState = STATE_SENT_PADI;
waitForPADO(conn, timeout);
/* If we're just probing for access concentrators, don't do
exponential backoff. This reduces the time for an unsuccessful
probe to 15 seconds. */
if (!conn->printACNames) {
timeout *= 2;
}
if (conn->printACNames && conn->numPADOs) {
break;
}
} while (conn->discoveryState == STATE_SENT_PADI);
/* If we're only printing access concentrator names, we're done */
if (conn->printACNames) {
exit(0);
}
timeout = conn->discoveryTimeout;
padrAttempts = 0;
do {
#ifdef PLUGIN
if (got_sigterm || got_sighup) return;
#endif
padrAttempts++;
if (padrAttempts > MAX_PADI_ATTEMPTS) {
if (persist) {
padrAttempts = 0;
timeout = conn->discoveryTimeout;
printErr("Timeout waiting for PADS packets");
/* Go back to sending PADI again */
goto SEND_PADI;
} else {
#ifdef PLUGIN
printErr("Timeout waiting for PADS packets");
return;
#else
rp_fatal("Timeout waiting for PADS packets");
#endif
}
}
sendPADR(conn);
conn->discoveryState = STATE_SENT_PADR;
waitForPADS(conn, timeout);
timeout *= 2;
} while (conn->discoveryState == STATE_SENT_PADR);
#ifdef PLUGIN
if (!conn->seenMaxPayload) {
/* RFC 4638: MUST limit MTU/MRU to 1492 */
if (lcp_allowoptions[0].mru > ETH_PPPOE_MTU) lcp_allowoptions[0].mru = ETH_PPPOE_MTU;
if (lcp_wantoptions[0].mru > ETH_PPPOE_MTU) lcp_wantoptions[0].mru = ETH_PPPOE_MTU;
}
#endif
/* We're done. */
conn->discoveryState = STATE_SESSION;
return;
}
