Chapter 3 - Description of NetX Duo Point-to-Point Protocol (PPP) services

UINT nx_ppp_byte_receive(
    NX_PPP *ppp_ptr,
    UCHAR byte);

/* Notify "my_ppp" of a received byte. */
status =  nx_ppp_byte_receive(&my_ppp, new_byte);

/* If status is NX_SUCCESS the received byte was successfully
   buffered. */

UINT nx_ppp_chap_challenge(NX_PPP *ppp_ptr);

/* Initiate a PPP challenge for instance "my_ppp". */
status =  nx_ppp_chap_challenge(&my_ppp);

/* If status is NX_SUCCESS a CHAP challenge "my_ppp" was successfully
initiated. */

UINT nx_ppp_chap_enable(
    NX_PPP *ppp_ptr,
    UINT (*get_challenge_values)(
        CHAR *rand_value,
        CHAR *id,
        CHAR *name),
    UINT (*get_responder_values)(
        CHAR *system,
        CHAR *name,
        CHAR *secret),
    UINT (*get_verification_values)(
        CHAR *system,
        CHAR *name,
        CHAR *secret));

CHAR    name_string[] = "username";
CHAR    rand_value_string[] = "123456";
CHAR    system_string[] = "system";
CHAR    secret_string[] = "secret";

/* Enable CHAP in both directions (CHAP challenger and CHAP responder) for
"my_ppp". */
status =  nx_ppp_chap_enable(&my_ppp,	get_challenge_values,
                              get_responder_values,
                              get_verification_values);


/* If status is NX_SUCCESS, "my_ppp" has CHAP enabled. */
/* Define the CHAP enable routines.  */
UINT  get_challenge_values(CHAR *rand_value, CHAR *id, CHAR *name)
{
   UINT    i;
   for (i = 0; i< (NX_PPP_NAME_SIZE-1); i++)
   {
      name[i] = name_string[i];
   }
   name[i] =  0;

   *id =  '1';  /* One byte  */
   for (i = 0; i< (NX_PPP_VALUE_SIZE-1); i++)
   {
      rand_value[i] =  rand_value_string[i];
   }
   rand_value[i] =  0;

   return(NX_SUCCESS);
}


UINT  get_responder_values(CHAR *system, CHAR *name, CHAR *secret)
{
   UINT    i;

   for (i = 0; i< (NX_PPP_NAME_SIZE-1); i++)
   {
      name[i] = name_string[i];
   }
   name[i] =  0;

   for (i = 0; i< (NX_PPP_NAME_SIZE-1); i++)
   {
      system[i] =  system_string[i];
   }
   system[i] =  0;

   for (i = 0; i< (NX_PPP_NAME_SIZE-1); i++)
   {
      secret[i] =  secret_string[i];
   }
   secret[i] =  0;

   return(NX_SUCCESS);
}

UINT  get_verification_values(CHAR *system, CHAR *name, CHAR *secret)
{
   UINT    i;

   for (i = 0; i< (NX_PPP_NAME_SIZE-1); i++)
   {
      name[i] = name_string[i];
   }
   name[i] =  0;

   for (i = 0; i< (NX_PPP_NAME_SIZE-1); i++)
   {
      system[i] =  system_string[i];
   }
   system[i] =  0;

   for (i = 0; i< (NX_PPP_NAME_SIZE-1); i++)
   {
      secret[i] =  secret_string[i];
   }
   secret[i] =  0;

   return(NX_SUCCESS);
}

UINT  nx_ppp_create(
    NX_PPP *ppp_ptr,
    CHAR *name,
    NX_IP *ip_ptr,
    VOID *stack_memory_ptr,
    ULONG stack_size,
    UINT thread_priority,
    NX_PACKET_POOL *pool_ptr,
    void (*ppp_invalid_packet_handler)(NX_PACKET *packet_ptr),
    void (*ppp_byte_send)(UCHAR byte));

/* Create "my_ppp" for IP instance "my_ip". */
status =  nx_ppp_create(&my_ppp, "my PPP", &my_ip, stack_start, 1024, 2,
                        &my_pool, my_invalid_packet_handler, my_out_byte);

/* If status is NX_SUCCESS the PPP instance was successfully
   created. */

UINT nx_ppp_delete(NX_PPP *ppp_ptr);

/* Delete PPP instance "my_ppp". */
status =  nx_ppp_delete(&my_ppp);

/* If status is NX_SUCCESS the "my_ppp" was successfully deleted. */

UINT nx_ppp_dns_address_get(
    NX_PPP *ppp_ptr,
    ULONG *dns_address_ptr);

ULONG  my_dns_address;

/* Get DNS Server address supplied by peer. */
status =  nx_ppp_dns_address_get(&my_ppp, &my_dns_address);

/* If status is NX_SUCCESS the "my_dns_address" contains the DNS IP address –
   if the peer supplied one. */

UINT nx_ppp_secondary_dns_address_get(
    NX_PPP *ppp_ptr,
    ULONG *dns_address_ptr);

ULONG  my_dns_address;

/* Get secondary DNS Server address supplied by peer. */
status =  nx_ppp_secondary_dns_address_get(&my_ppp, &my_dns_address);

/* If status is NX_SUCCESS the "my_dns_address" contains the secondary DNS Server address – if the peer supplied one. */

UINT nx_ppp_dns_address_set(
    NX_PPP *ppp_ptr,
    ULONG dns_address);

ULONG  my_dns_address = IP_ADDRESS(1,2,3,1);

/* Set DNS Server address. */
status =  nx_ppp_dns_address_set(&my_ppp, my_dns_address);

/* If status is NX_SUCCESS the "my_dns_address" will be the DNS Server address provided if the peer requests one. */

UINT nx_ppp_secondary_dns_address_set(
    NX_PPP *ppp_ptr,
    ULONG dns_address);

ULONG  my_dns_address = IP_ADDRESS(1,2,3,1);

/* Set DNS Server address. */
status =  nx_ppp_secondary_dns_address_set(&my_ppp, my_dns_address);

/* If status is NX_SUCCESS the "my_dns_address" will be the secondary DNS Server address provided if the peer requests one. */

UINT nx_ppp_interface_index_get(
    NX_PPP *ppp_ptr,
    UINT *index_ptr);

ULONG  my_index;

/* Get the interface index for this PPP instance. */
status =  nx_ppp_interface_index_get(&my_ppp, &my_index);

/* If status is NX_SUCCESS the "my_index" contains the IP interface index for
   this PPP instance. */

UINT nx_ppp_ip_address_assign(
    NX_PPP *ppp_ptr,
    ULONG local_ip_address,
    ULONG peer_ip_address);

/* Set IP addresses for "my_ppp". */
status =  nx_ppp_ip_address_assign(&my_ppp, IP_ADDRESS(256,2,2,187),
IP_ADDRESS(256,2,2,188));


/* If status is NX_SUCCESS the "my_ppp" has the IP addresses. */

UINT nx_ppp_link_down_notify(
    NX_PPP *ppp_ptr,
    VOID (*link_down_callback)(NX_PPP *ppp_ptr));

/* Register "my_link_down_callback" to be called whenever the PPP
   link goes down. */
status =  nx_ppp_link_down_notify(&my_ppp, my_link_down_callback);


/* If status is NX_SUCCESS the function "my_link_down_callback" has been
   registered with this PPP instance. */

VOID my_link_down_callback(NX_PPP *ppp_ptr)
{

/* On link down, simply restart PPP.  */
    nx_ppp_restart(ppp_ptr);
}

UINT nx_ppp_link_up_notify(
    NX_PPP *ppp_ptr,
    VOID (*link_up_callback)(NX_PPP *ppp_ptr));

/* Register "my_link_up_callback" to be called whenever the PPP
   link comes up. */
status =  nx_ppp_link_up_notify(&my_ppp, my_link_up_callback);


/* If status is NX_SUCCESS the function "my_link_up_callback" has been
   registered with this PPP instance. */

VOID my_link_up_callback(NX_PPP *ppp_ptr)
{
    /* On link up, the application my want to start sending/receiving
       UPD/TCP data.  */
}

UINT    nx_ppp_nak_authentication_notify(
    NX_PPP *ppp_ptr,
    void (*nak_authentication_notify)(void));

/* Register "my_nak_auth_callback" to be called whenever the PPP
   receives a NAK during authentication. */
status =  nx_ppp_nak_authentication_notify(&my_ppp, my_nak_auth_callback);

/* If status is NX_SUCCESS the function "my_nak_auth_callback" has been
   registered with this PPP instance. */

VOID my_nak_auth_callback(NX_PPP *ppp_ptr)
{
   /* Handle the situation of receiving an authentication NAK */
}

UINT  nx_ppp_pap_enable(
    NX_PPP *ppp_ptr,
    UINT (*generate_login)(CHAR *name, CHAR *password),
    UINT (*verify_login)(CHAR *name, CHAR *password));

CHAR    name_string[] = "username";
CHAR    password_string[] =  "password";

/* Enable PAP for PPP instance "my_ppp". */
status =  nx_ppp_pap_enable(&my_ppp, my_generate_login, my_verify_login);

/* If status is NX_SUCCESS the "my_ppp" now has PAP enabled. */

/* Define callback routines for PAP enable.  */

UINT  generate_login(CHAR *name, CHAR *password)
{

UINT    i;

for (i = 0; i< (NX_PPP_NAME_SIZE-1); i++)
name[i] = name_string[i];
name[i] =  0;

for (i = 0; i< (NX_PPP_PASSWORD_SIZE-1); i++)
password[i] = password_string[i];
password_string[i] =  0;

return(NX_SUCCESS);
}

UINT  verify_login(CHAR *name, CHAR *password)
{

/* Assume name and password are correct. Normally,
a comparison would be made here!  */
printf("Name: %s, Password: %s\n", name, password);

return(NX_SUCCESS);
}

UINT  nx_ppp_ping_request(
    NX_PPP *ppp_ptr,
    CHAR *data,
    UINT data_size,
    ULONG wait_option);

CHAR    buffer[] = "username";
UINT    buffer_length =  sizeof("username ") - 1;

/* Send an LCP ping request". */
status =  nx_ppp_ping_request(&my_ppp, &buffer[0], buffer_length, 200);

/* If status is NX_SUCCESS the LCP echo request was successfully sent. Now wait to
   receive a response. */

while(my_ppp.nx_ppp_lcp_echo_reply_id > 0)
{
	tx_thread_sleep(100);
}

/* Got a valid reply! */

UINT  nx_ppp_raw_sting_send(
    NX_PPP *ppp_ptr,
    CHAR *string_ptr);

/* Send "CLIENTSERVER" to "CLIENT" sent by Windows 98 before PPP is
initiated.  */
status =  nx_ppp_raw_string_send(&my_ppp, "CLIENTSERVER");

/* If status is NX_SUCCESS the raw string was successfully Sent via PPP. */

UINT  nx_ppp_restart(NX_PPP *ppp_ptr);

/* Restart the PPP instance "my_ppp".  */
status =  nx_ppp_restart(&my_ppp);

/* If status is NX_SUCCESS the PPP instance has been restarted. */

UINT  nx_ppp_start(NX_PPP *ppp_ptr);

/* Start the PPP instance "my_ppp".  */
status =  nx_ppp_start(&my_ppp);

/* If status is NX_SUCCESS the PPP instance has been started. */

UINT  nx_ppp_status_get(
    NX_PPP *ppp_ptr,
    UINT *status_ptr);

UINT ppp_status;
UINT status;


/* Get the current status of PPP instance "my_ppp".  */
status =  nx_ppp_status_get(&my_ppp, &ppp_status);

/* If status is NX_SUCCESS the current internal PPP status is contained in
   "ppp_status". */

UINT  nx_ppp_stop(NX_PPP *ppp_ptr);

/* Stop the PPP instance "my_ppp".  */
status =  nx_ppp_stop(&my_ppp);

/* If status is NX_SUCCESS the PPP instance has been stopped. */

UINT  nx_ppp_packet_receive(
    NX_PPP *ppp_ptr,
    NX_PACKET *packet_ptr);

/* Receive the PPP packet of PPP instance "my_ppp".  */
status =  nx_ppp_packet_receive(&my_ppp, packet_ptr);

/* If status is NX_SUCCESS the PPP packet has received. */

UINT  nx_ppp_packet_send_set(
    NX_PPP *ppp_ptr,
    VOID (*nx_ppp_packet_send)(NX_PACKET *packet_ptr));

/* Set the PPP packet send function of PPP instance "my_ppp".  */
status =  nx_ppp_packet_send_set(&my_ppp, nx_ppp_packet_send);

/* If status is NX_SUCCESS the PPP packet send function has set. */