[lwip-users] PPPoS BSD Socket stucks in the listening state... FreeRTOS, pppAPI, RawAPI Netconn

[sarp]

I am using Telit GL865 GSM module and, came to the stage of opening a TCP
server socket over PPPoS.

I tried to open using both Netconn, BSD and Raw APIs; however, they both
stuck in the listening state.

At the client side, connection seems established even server does not
accept, 
meaning that accept callback is never called, the stack cannot accept the
connections.

PPPoS TCP Server and Ethernet TCP Server implementations have 2 different
main aspects as follows:
1) "netif" callback; for ethernet: ethernetif_update_config is used and, for
PPPoS what you implement..
2) how to feed the "netif"; ethernetif_input() for ethernet and
pppos_tcpip_input() for PPP.

Code consists of 2 threads, one is for feeding ppp and the other is to
create the server over BSD:


/* Includes
------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "cmsis_os.h"

/* USER CODE BEGIN Includes */     
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include "string.h"
#include "main.h"
#include "stm32f7xx_hal.h"
#include "cmsis_os.h"
#include "lwip.h"
#include "usart.h"
#include "gpio.h"
#include <stdio.h>
#include "string.h"
#include <time.h>
#include "lwip/opt.h"
#include "lwip/sys.h"
#include "lwip/timeouts.h"
#include "lwip/debug.h"
#include "lwip/stats.h"
#include "lwip/init.h"
#include "lwip/tcpip.h"
#include "lwip/netif.h"
#include "lwip/api.h"
#include "lwip/tcp.h"
#include "lwip/udp.h"
#include "lwip/dns.h"
#include "lwip/dhcp.h"
#include "lwip/autoip.h"
#include "lwip/etharp.h"
#include "netif/ethernet.h"
#include "lwip/apps/netbiosns.h"
#include "lwip/apps/httpd.h"
#include "lwip/sio.h"
#include "pppapi.h"
#include <lwip/sockets.h> 
#include "usart.h"
#include "test.h"
#include "timeouts.h"
#include "main.h"
#include "lwip/opt.h"
#include "lwip/init.h"
#include "lwip/netif.h"
#include "lwip/timeouts.h"
#include "netif/etharp.h"
#include "ethernetif.h"
#include "netif.h"
#include "lwip/timeouts.h"

#define RX_SIZE 4096
/* USER CODE END Includes */

/* Variables
-----------------------------------------------------------------*/
osThreadId defaultTaskHandle;
osThreadId clientTaskHandle;

/* USER CODE BEGIN Variables */
uint32_t sysTickCounter, runTimeCnt, recIndex = 0;
uint8_t recData, called, connectionStatus, send, dataReceived, gsmInitEnd,
tcpClientConnected, emptyFlag, lwipInit, tcpTimerCounter = 0;
uint8_t recBuffer[RX_SIZE];
ppp_pcb *ppp;
struct netif ppp_netif;
static struct tcp_pcb *tcp_echoserver_pcb, *echoclient_pcb;
int socket_fd;
char data_buffer[80];


/* USER CODE END Variables */

/* Function prototypes
-------------------------------------------------------*/
void StartDefaultTask(void const * argument);
void startClientTask(void const * argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/* USER CODE BEGIN FunctionPrototypes */

void gsmInitAT(void);

static void netif_link_callback(struct netif *state_netif) { 
    if (netif_is_link_up(state_netif)) { 
        printf("NETIF link_callback = UP\r\n"); 
    }else{ 
        printf("NETIF link_callback = DOWN\r\n");  
    } 
} 
void ppp_notify_phase_cb(ppp_pcb *pcb, u8_t phase, void *ctx) { 
        char str[32]; 
        switch (phase){ 
                case PPP_PHASE_DEAD: 
                        strcpy(str, "PPP_PHASE_DEAD");   
                        break; 
                case PPP_PHASE_MASTER: strcpy(str, "PPP_PHASE_MASTER");
break; 
                case PPP_PHASE_HOLDOFF: strcpy(str, "PPP_PHASE_HOLDOFF");
break; 
                case PPP_PHASE_INITIALIZE: strcpy(str,
"PPP_PHASE_INITIALIZE"); break; 
                case PPP_PHASE_SERIALCONN: strcpy(str,
"PPP_PHASE_SERIALCONN"); break; 
                case PPP_PHASE_DORMANT: strcpy(str, "PPP_PHASE_DORMANT");
break; 
                case PPP_PHASE_ESTABLISH: strcpy(str,
"PPP_PHASE_ESTABLISH"); break; 
                case PPP_PHASE_AUTHENTICATE: strcpy(str,
"PPP_PHASE_AUTHENTICATE"); break; 
                case PPP_PHASE_CALLBACK: strcpy(str, "PPP_PHASE_CALLBACK");
break; 
                case PPP_PHASE_NETWORK: strcpy(str, "PPP_PHASE_NETWORK");
break; 
                case PPP_PHASE_RUNNING: strcpy(str, "PPP_PHASE_RUNNING");
break; 
                case PPP_PHASE_TERMINATE: strcpy(str,
"PPP_PHASE_TERMINATE"); break; 
                case PPP_PHASE_DISCONNECT: strcpy(str,
"PPP_PHASE_DISCONNECT"); break; 
                default: strcpy(str, "UNKNOWN"); break; 
        } 
        printf("PPP phase = %s (%d) \r\n", str, phase); 
} 
static void netif_status_callback(struct netif *state_netif) { 
        if (netif_is_up(state_netif)) { 
            printf("NETIF status_callback = UP, local interface IP is
%s\r\n", ip4addr_ntoa(netif_ip4_addr(state_netif))); 
        } else { 
            printf("NETIF status_callback = DOWN\r\n"); 
        } 
} 
static void ppp_link_status_cb(ppp_pcb *pcb, int err_code, void *ctx) {
        struct netif *pppif = ppp_netif(pcb);
        called = 1;
        
        //LWIP_UNUSED_ARG(ctx);
        switch(err_code) {
                case PPPERR_NONE: {
                        connectionStatus = 1;
                        
                        printf("status_cb: Connected\n");
                        printf("   our_ipaddr  = %s\r\n", 
ipaddr_ntoa(&pppif->ip_addr));
                        printf("   gatewayaddr = %s\r\n", 
ipaddr_ntoa(&pppif->gw));
                        printf("   netmask     = %s\r\n", 
ipaddr_ntoa(&pppif->netmask));
                        
                        //                      
                        //tcp_echoclient_connect();
                        break;
                }
                case PPPERR_PARAM: {
                        connectionStatus = 2;
                        printf("status_cb: Invalid parameter\r\n");
                        break;
                }
                case PPPERR_OPEN: {
                        connectionStatus = 3;
                        printf("status_cb: Unable to open PPP session\r\n");
                        break;
                }
                case PPPERR_DEVICE: {
                        connectionStatus = 4;
                        printf("status_cb: Invalid I/O device for PPP\r\n");
                        break;
                }
                case PPPERR_ALLOC: {
                        connectionStatus = 5;
                        printf("status_cb: Unable to allocate resources\r\n");
                        break;
                }
                case PPPERR_USER: {
                        connectionStatus = 6;
                        ppp_free(pcb);
                        printf("status_cb: User interrupt\r\n");
                        break;
                }
                case PPPERR_CONNECT: {
                        connectionStatus = 7;
                        printf("status_cb: Connection lost\r\n");
                        break;
                }
                case PPPERR_AUTHFAIL: {
                        connectionStatus = 8;
                        printf("status_cb: Failed authentication 
challenge\r\n");
                        break;
                }
                case PPPERR_PROTOCOL: {
                        connectionStatus = 9;
                        printf("status_cb: Failed to meet protocol\r\n");
                        break;
                }
                case PPPERR_PEERDEAD: {
                        connectionStatus = 10;
                        printf("status_cb: Connection timeout\r\n");
                        break;
                }
                case PPPERR_IDLETIMEOUT: {
                        connectionStatus = 11;
                        printf("status_cb: Idle Timeout\r\n");
                        break;
                }
                case PPPERR_CONNECTTIME: {
                        connectionStatus = 12;
                        printf("status_cb: Max connect time reached\r\n");
                        break;
                }
                case PPPERR_LOOPBACK: {
                        connectionStatus = 13;
                        printf("status_cb: Loopback detected\r\n");
                        break;
                }
                default: {
                        connectionStatus = 14;
                        printf("status_cb: Unknown error code %d\r\n", 
err_code);
                        break;
                }
        }
}
static u32_t ppp_output_cb(ppp_pcb *pcb, u8_t *data, u32_t len, void *ctx){
        printf("sent:     %s with length: %d\r\n", data, len);
        return HAL_UART_Transmit_IT(&huart1, data, len);
}

/* USER CODE END FunctionPrototypes */

/* Hook prototypes */

/* Init FreeRTOS */

void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */
       
  /* USER CODE END Init */

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* Create the thread(s) */
  /* definition and creation of defaultTask */
  osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 1024);
  defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);

  /* definition and creation of clientTask */
  osThreadDef(clientTask, startClientTask, osPriorityNormal, 0, 1024);
  clientTaskHandle = osThreadCreate(osThread(clientTask), NULL);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */
}

/* StartDefaultTask function */
void StartDefaultTask(void const * argument)
{
  /* init code for LWIP */
  MX_LWIP_Init();
        tcpip_init(NULL,NULL);
  /* USER CODE BEGIN StartDefaultTask */
        lwipInit = 1;
        //SysTick_Config(SystemCoreClock/1000); 
        
        HAL_UART_Receive_IT(&huart1, &recData, 1);
        // Infinite loop 
        gsmInitAT();
        
        ppp = pppapi_pppos_create(&ppp_netif, ppp_output_cb, ppp_link_status_cb,
NULL);
    if (ppp == NULL) {
        printf("Error init pppos");
        return;
    }
    pppapi_set_default(ppp);
    //ppp_set_auth(ppp, PPPAUTHTYPE_NONE, "", "");
        pppapi_listen(ppp);
        //pppapi_connect(ppp,0);
        netif_set_default(&ppp_netif); 
        netif_set_status_callback(&ppp_netif, netif_status_callback); 
    pppapi_set_notify_phase_callback(ppp, ppp_notify_phase_cb); 
    netif_set_link_callback(&ppp_netif, netif_link_callback);
        
        for(;;)
        {
                if(gsmInitEnd){
                        if(send){
                                send = 0;
                                pppos_input_tcpip(ppp, recBuffer, recIndex);
                                printf("received: %s with length: %d\r\n", 
recBuffer, recIndex);
                                recIndex = 0;
                                memset(recBuffer, 0, sizeof(recBuffer));
                                runTimeCnt++;
                        }
                }
        }
  /* USER CODE END StartDefaultTask */
}

/* startClientTask function */
void startClientTask(void const * argument)
{
  /* USER CODE BEGIN startClientTask */
        while (netif_is_link_up(&ppp_netif) == 0)       HAL_Delay(1000);
        //tcp_echoserver_init();
        
        int sock, newconn, size, sent_data, recv_data;
        struct sockaddr_in address, remotehost;

        sock = socket(AF_INET, SOCK_STREAM, 0);
        
        address.sin_family = AF_INET;
        address.sin_port = htons(502);
        address.sin_addr.s_addr = INADDR_ANY;

        bind(sock, (struct sockaddr *)&address, sizeof (address));
        listen(sock, 5);
        size = sizeof(remotehost);
        
  /* Infinite loop */
  for(;;)
  {
          newconn = accept(sock, (struct sockaddr *)&remotehost, (socklen_t
*)&size);
          
          //recv_data = recv(newconn, data_buffer, sizeof(data_buffer), 0);
      //sent_data = send(newconn, "Hello World", strlen("Hello World"),0);
  }
  /* USER CODE END startClientTask */
}

/* USER CODE BEGIN Application */
void gsmInitAT(void){
        
        HAL_Delay(500); 
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT\r\n", strlen("AT\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT&K0\r\n", 
strlen("AT&K0\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, 
(uint8_t*)"AT#SCFG=3,1,300,600,300,10\r\n",
strlen("AT#SCFG=3,1,300,600,300,10\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT#SLED=2,2,2\r\n",
strlen("AT#SLED=2,2,2\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT#SLEDSAV\r\n",
strlen("AT#SLEDSAV\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1,
(uint8_t*)"AT+CGDCONT=1,\"IP\",\"mgbs\",\"0.0.0.0\",0,0\r\n",
strlen("AT+CGDCONT=1,\"IP\",\"mgbs\",\"0.0.0.0\",0,0\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT+CGSN\r\n",
strlen("AT+CGSN\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT#ICMP=2\r\n",
strlen("AT#ICMP=2\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT+CSQ\r\n",
strlen("AT+CSQ\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT+CCLK?\r\n",
strlen("AT+CCLK?\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1,
(uint8_t*)"AT#GPPPCFG=\"000.000.000.000\",25,1\r\n",
strlen("AT#GPPPCFG=\"000.000.000.000\",25,1\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT#GPPPCFGEXT=0\r\n",
strlen("AT#GPPPCFGEXT=0\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"AT#GAUTH=0\r\n",
strlen("AT#GAUTH=0\r\n"));
        HAL_Delay(500);
        memset(recBuffer, 0, sizeof(recBuffer));
        recIndex = 0;
        HAL_UART_Transmit_IT(&huart1, (uint8_t*)"ATDT*99***1#\r\n",
strlen("ATDT*99***1#\r\n"));
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle){
        if (UartHandle->Instance == USART1)
        {
                
                HAL_UART_Receive_IT(&huart1, &recData, 1);
                
                if(recIndex >= RX_SIZE){
                        recIndex = 0;
                }       
                
                dataReceived = 1;
                sysTickCounter = 0;
                send = 0;
                
                if(recData == 0x7E)
                {
                        if(gsmInitEnd == 0){
                                recIndex = 0;
                                memset(recBuffer, 0, sizeof(recBuffer));
                        }
                        gsmInitEnd = 1;
                }
                recBuffer[recIndex++] = recData;
        }
}
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *UartHandle){
        
        
        
        /* Turn LED1 on: Transfer in transmission process is correct */
}

/* USER CODE END Application */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF
FILE****/






--
Sent from: http://lwip.100.n7.nabble.com/lwip-users-f3.html