+
−/*-*- c-basic-offset: 2 -*-
+
−+------------------------------------------------------------------------------
+
−|  File:       app_core.c
+
−+------------------------------------------------------------------------------
+
−|  Copyright 2003 Texas Instruments Berlin, AG
+
−|                 All rights reserved.
+
−|
+
−|                 This file is confidential and a trade secret of Texas
+
−|                 Instruments Berlin, AG
+
−|                 The receipt of or possession of this file does not convey
+
−|                 any rights to reproduce or disclose its contents or to
+
−|                 manufacture, use, or sell anything it may describe, in
+
−|                 whole, or in part, without the specific written consent of
+
−|                 Texas Instruments Berlin, AG.
+
−+-----------------------------------------------------------------------------
+
−|  Purpose :  Example application for TCP/IP and Socket API -- core functions.
+
−+-----------------------------------------------------------------------------
+
−*/
+
−
+
−
+
−/* This should only be compiled into the entity if TCP/IP is enabled */
+
−#ifdef FF_GPF_TCPIP
+
−
+
−#define APP_CORE_C
+
−
+
−#define ENTITY_APP
+
−
+
−/*==== INCLUDES =============================================================*/
+
−
+
−#include <string.h>             /* String functions, e. g. strncpy(). */
+
−#include <ctype.h>
+
−#include <stdio.h>
+
−#include <stdlib.h>
+
−#ifndef _SIMULATION_
+
−#include "typedefs.h"           /* Condat data types. */
+
−#endif /* _SIMULATION_ */
+
−#include "vsi.h"                /* A lot of macros. */
+
−#ifndef _SIMULATION_
+
−#include "custom.h"
+
−#include "gsm.h"                /* A lot of macros. */
+
−#include "prim.h"               /* Definitions of used SAP and directions. */
+
−#include "pei.h"                /* PEI interface. */
+
−#include "tools.h"              /* Common tools. */
+
−#endif /* _SIMULATION_ */
+
−#include "socket_api.h"             /* Socket API. */
+
−#include "app.h"                /* Global entity definitions. */
+
−
+
−
+
−/*==== Local data ============================================================*/
+
−
+
−#define NPROCS 1                /* Maximum number of application processes. */
+
−
+
−#define PORT_CHARGEN 19         /* Chargen service for download. */
+
−#define PORT_ECHO     7         /* Echo port for tcpecho and udpecho. */
+
−#define PORT_DISCARD  9         /* Discard port for upload. */
+
−
+
−#define FQDN_LENGTH 255         /* Maximum length of a fully-qualified domain
+
−                                 * name. */
+
−
+
−#undef HTONS
+
−#define HTONS(a) ((((a) & 0xff) << 8) | (((a) & 0xff00) >> 8))
+
−#undef NTOHS
+
−#define NTOHS(a) HTONS(a)
+
−#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
−
+
−/* We can run different types of application processes, according to the
+
− * commend sent by the user. */
+
−typedef enum {
+
−  AP_NONE,                      /* For uninitialized process types. */
+
−  AP_TCPDL,                     /* Download some data over TCP. */
+
−  AP_TCPUL,                     /* Upload some data over TCP. */
+
−  AP_UDPDL,                     /* Download some data over UDP. */
+
−  AP_UDPUL,                     /* Upload some data over UDP. */
+
−  AP_TCPECHO,                   /* Send/receive data to/from TCP echo port. */
+
−  AP_UDPECHO,                   /* Send/receive data to/from UDP echo port. */
+
−  AP_TCPSRV,                    /* TCP server application. */
+
−  AP_DNSQRY,                    /* Issue DNS queries and collect result. */
+
−  AP_TCPFORK,                   /* Forked TCP server process. */
+
−  AP_INVALID
+
−} APP_PROCTYPE_T ;
+
−
+
−/* Strings for process types; used for debugging and MUST correspond strictly
+
− * to the process type enum labels defined above. */
+
−static char *proc_type_name[] = {
+
−  "AP_NONE",                    /* 00 */
+
−  "AP_TCPDL",                   /* dl */
+
−  "AP_TCPUL",                   /* ul */
+
−  "AP_UDPDL",
+
−  "AP_UDPUL",
+
−  "AP_TCPECHO",                 /* te */
+
−  "AP_UDPECHO",                 /* ue */
+
−  "AP_TCPSRV",
+
−  "AP_DNSQRY",                  /* dq */
+
−  "AP_TCPFORK",
+
−  "AP_INVALID"
+
−} ;
+
−
+
−/* Process states; the state transitions are mostly linear in this order. */
+
−typedef enum {
+
−  PS_IDLE,                      /* Initial state, process not running. */
+
−  PS_W_DCM_OPEN,                /* Waiting for DCM to open connection. */
+
−  PS_W_DCM_OPEN_ONLY,           /* Waiting for DCM to open connection - no further action. */
+
−  PS_W_CREAT,                   /* Waiting for socket create confirmation. */
+
−  PS_W_SCONN,                   /* Waiting for socket connect confirmation. */
+
−  PS_W_BIND,                    /* Waiting for socket bind confirmation. */
+
−  PS_W_LISTN,                   /* Waiting for confirmation of listen call. */
+
−  PS_LISTENS,                   /* Listens for client connections. */
+
−  PS_W_DNS,                     /* Waiting for a DNS query. */
+
−  PS_COMM,                      /* Happily exchanging data. */
+
−  PS_W_SCLOS,                   /* Waiting for socket close confirmation. */
+
−  PS_W_DCLOS,                   /* Waiting for DCM to close connection. */
+
−  PS_W_CONN_INFO,               /* Waiting for connection information */
+
−  PS_DCM_OPEN,                  /* DCM (bearer) connecion opened*/
+
−  PS_SOCK_OPEN,                 /* Socket and bearer open */
+
−  PS_INVALID
+
−} PROC_STAT_T ;
+
−
+
−/* Strings for the process states; used for debugging and MUST correspond
+
− * strictly to the process state enum labels defined above, as the array is
+
− * indexed by those. */
+
−static char *proc_state_name[] = {
+
−  "PS_IDLE",
+
−  "PS_W_DCM_OPEN",
+
−  "PS_W_DCM_OPEN_ONLY",
+
−  "PS_W_CREAT",
+
−  "PS_W_SCONN",
+
−  "PS_W_BIND",
+
−  "PS_W_LISTN",
+
−  "PS_W_LISTENS",
+
−  "PS_W_DNS",
+
−  "PS_COMM",
+
−  "PS_W_SCLOS",
+
−  "PS_W_DCLOS",
+
−  "PS_W_CONN_INFO",
+
−  "PS_DCM_OPEN",
+
−  "PS_SOCK_OPEN",
+
−  "PS_INVALID"
+
−} ;
+
−
+
−/* The data a process holds. May be dynamically allocated in the future. */
+
−typedef struct PROCESS_CONTEXT_S {
+
−  APP_PROCTYPE_T ptype ;        /* Type of application process */
+
−  PROC_STAT_T pstate ;          /* Process status as defined above. */
+
−  int in_shutdown ;             /* Non-zero iff process is being shut down. */
+
−  T_SOCK_EVENTSTRUCT *last_evt; /* Last event passed from the Socket API. */
+
−  T_SOCK_IPPROTO ipproto ;      /* IP protocol number for this process (TCP or
+
−                                 * UDP); unused with dq. */
+
−  char *server_name ;           /* May be a domain name or an IP address in
+
−                                 * dotted decimal notation. */
+
−  T_SOCK_IPADDR server_ipaddr ; /* Server IP address. (Will be IPADDR_ANY in
+
−                                 * case of AP_TCPSRV.) */
+
−  T_SOCK_PORT server_port ;     /* Server port number. (Also in case of
+
−                                 * AP_TCPSRV.) */
+
−
+
−  /* The following variables are in use only where appropriate, of course --
+
−   * as indicated in the comment. */
+
−
+
−  int f_id ;                    /* Identity of TCP server fork. */
+
−  int spec_items ;              /* Specified number of items to transfer. (The
+
−                                 * items are single bytes for dl and ul.) */
+
−  int spec_reps ;               /* Specified number of repetitions. */
+
−
+
−  int data_sent ;               /* Total amount of data sent (ul, te, ue). */
+
−  int data_rcvd ;               /* Total amount of data recvd (dl, te, ue). */
+
−  int items_sent ;              /* Number of blocks/packets/queries sent (ul,
+
−                                 * te, ue, dq). */
+
−  int items_rcvd ;              /* Number of blocks/packets/responses received
+
−                                 * (dl, te, ue, dq). */
+
−  int n_reps ;                  /* Number of repetitions done. */
+
−  int errors ;                  /* Number of errors at all. */
+
−  T_SOCK_SOCKET psocket ;       /* The socket in use by the process. */
+
−  int network_is_open ;         /* Non-zero iff we have an open network
+
−                                 * connection. */
+
−  int psocket_is_open ;         /* Non-zero iff we have an open psocket. */
+
−  BOOL bearer_only;             /* if set, only a Bearer will be opened */ 
+
−} PROC_CONTEXT_T ;
+
−
+
−static PROC_CONTEXT_T proc_context ;
+
−static PROC_CONTEXT_T cl_context[APP_N_CLIENTS] ;
+
−static char server_name[FQDN_LENGTH+1] = APP_DEF_SERVER ;
+
−                                /* Global server name. */
+
−static char query_name[FQDN_LENGTH+1] = APP_DEF_DNSQUERY_ADDR ;
+
−static int buffer_size = APP_DEF_BUFFER_SIZE ;
+
−static U16 port_number = 0 ;    /* Port number override if non-zero. */
+
−static int udp_interval = APP_DEF_UDP_INTERVAL ;
+
−static T_SOCK_BEARER_TYPE bearer_select    = SOCK_BEARER_AS_SPECIFIED;
+
−static T_SOCK_BEARER_TYPE sock_bearer_type = SOCK_BEARER_GPRS;
+
−EXTERN BOOL custom_apn_valid;
+
−
+
−
+
−/* The cache for DNS queries is RNET_RT_RESOLV_CACHE_MAX queries big, i. e. 8
+
− * in the current configuration. We need to overflow this cache in order to
+
− * test lookup robustness. */
+
−static char *domain_name[] = {
+
−#ifdef _SIMULATION_              /* Not in the simulation, though. */
+
−  "chuck.berlin.tide.ti.com",
+
−#else  /* _SIMULATION_ */
+
−  "gsmtest.com",
+
−  "w21.org",
+
−  "gw.w21.org",
+
−  "troll.cs.tu-berlin.de",
+
−  "gatekeeper.dec.com",
+
−  "www.mcvax.org",
+
−  "www.mcvaymedia.com",
+
−  "www.vodafone.de",
+
−  "www.ti.com",
+
−  "mailbox.tu-berlin.de",
+
−  "ge-2-3-0.r02.asbnva01.us.bb.verio.net",
+
−  "www.condat.de",
+
−  "www.tellique.de",
+
−  "prz.tu-berlin.de",
+
−#endif /* _SIMULATION_ */
+
−  0
+
−} ;
+
−
+
−
+
−
+
−/*==== Local functions =======================================================*/
+
−
+
−/*
+
− * Utility functions.
+
− */
+
−
+
−
+
−static char *sock_bearer_type_string(T_SOCK_BEARER_TYPE btype)
+
−{
+
−  switch (btype)
+
−  {
+
−    case SOCK_BEARER_ANY: return "SOCK_BEARER_ANY" ;
+
−    case SOCK_BEARER_GPRS: return "SOCK_BEARER_GPRS" ;
+
−    case SOCK_BEARER_GSM: return "SOCK_BEARER_GSM" ;
+
−    case SOCK_BEARER_USE_PROFILE: return "SOCK_BEARER_USE_PROFILE" ;
+
−    case SOCK_BEARER_AS_SPECIFIED: return "SOCK_BEARER_AS_SPECIFIED" ;
+
−    default: return "<unknown bearer type>" ;
+
−  }
+
−}
+
−
+
−/** Give a print representation for the specified character. This is the
+
− * character itself for printable characters and a substitution character for
+
− * others.
+
− *
+
− * @param c    the character
+
− * @return     the print representation
+
− */
+
−static char p_char(char c)
+
−{
+
−  return isprint(c) ? c : '~' ;
+
−}
+
−
+
−
+
−#define DUMP_LLENGTH 16         /* Data dump line length. */
+
−#define DBUF_LENGTH (4 * DUMP_LLENGTH + 10) /* See example below. */
+
−#define XDIGIT(n) ("0123456789abcdef"[n])
+
−
+
−/** Dump the specified portion of the data as event traces like this:
+
− * 0000: 27 28 29 2a 2b 2c 2d 2e-2f 30 31 32 33 34 35 36 ['()*+,-./0123456]
+
− *
+
− * @param data    Pointer to data area
+
− * @param size    Size of data to dump
+
− */
+
−void trace_dump_data(U8 *data, int size)
+
−{
+
−  char dump_buf[DBUF_LENGTH] ;  /* Buffer to dump a line into. */
+
−  int lcount = 0 ;              /* Line count. */
+
−  int i ;                       /* Index into data. */
+
−  char *cp ;                    /* Pointer to current char in dump_buf[]. */
+
−
+
−  while (size > 0)
+
−  {
+
−    cp = dump_buf ;
+
−    /* Hex values. */
+
−    for (i = 0; i < DUMP_LLENGTH && i < size; i++)
+
−    {
+
−      *cp++ = XDIGIT(data[i] >> 4) ;
+
−      *cp++ = XDIGIT(data[i] & 0xf) ;
+
−      *cp++ = (i == DUMP_LLENGTH/2 - 1) ? '-' : ' ' ;
+
−    }
+
−
+
−    /* Fill up with blanks. */
+
−    for ( ; i < DUMP_LLENGTH; i++)
+
−    {
+
−      *cp++ = ' ' ; *cp++ = ' ' ; *cp++ = ' ' ;
+
−    }
+
−
+
−    /* Literal characters with some decoration. */
+
−    *cp++ = '[' ;
+
−    for (i = 0; i < DUMP_LLENGTH && i < size; i++, cp++)
+
−    {
+
−      *cp = p_char(data[i]) ;
+
−    }
+
−    *cp++ = ']' ;
+
−    *cp++ = 0 ;
+
−    TRACE_EVENT_P2("%04x: %s", DUMP_LLENGTH * lcount++, dump_buf) ;
+
−    size -= DUMP_LLENGTH ;
+
−    data += DUMP_LLENGTH ;
+
−  }
+
−}
+
−
+
−
+
−/** Build a string, characterizing a process, suitable for tracing. The string
+
− * is statically allocated and will be overwritten with the next call.
+
− *
+
− * @param pcont    Pointer to process context.
+
− * @return         The string.
+
− */
+
−char *proc_string(PROC_CONTEXT_T *pcont)
+
−{
+
−  /* This string must fit the longest possible process string. */
+
−  static char procstring[sizeof("AP_TCPFORK99(PS_W_DCM_OPEN_ONLY)")] ;
+
−
+
−  /*lint -e685 (Warning -- Relational operator always evaluates to true) */
+
−  sprintf(procstring, "%s%d(%s)",
+
−          pcont->ptype <= AP_INVALID  ? proc_type_name[pcont->ptype] : "AP_UNKNOWN",
+
−          pcont->ptype == AP_TCPFORK  ? pcont->f_id : 0,
+
−          pcont->pstate <= PS_INVALID ? proc_state_name[pcont->pstate] : "PS_UNKNOWN") ;
+
−  /*lint +e685 (Warning -- Relational operator always evaluates to true) */
+
−  return procstring ;
+
−}
+
−
+
−
+
−/** Converts a numeric IP address in network order into an IP address in
+
− * dotted decimal string notation. The string returned is statically allocated
+
− * and will be overwritten on the next call.
+
− *
+
− * @param ipaddr    The IP address in network order
+
− * @return String with the IP address in dotted decimal..
+
− */
+
−static char *inet_ntoa(T_SOCK_IPADDR ipaddr)
+
−{
+
−  U8 *addrbyte ;
+
−  static char addr_string[sizeof("000.000.000.000")] ;
+
−
+
−  addrbyte = (U8 *) &ipaddr ;
+
−  sprintf(addr_string, "%u.%u.%u.%u",
+
−          addrbyte[0], addrbyte[1], addrbyte[2], addrbyte[3]) ;
+
−  return addr_string ;
+
−}
+
−
+
−
+
−/** Converts an IP address in dotted decimal string notation into a numeric IP
+
− * address in network order.
+
− *
+
− * @param addr_string    String with the IP address in dotted decimal.
+
− * @return The IP address in network order, or SOCK_IPADDR_ANY if the address
+
− *         string cannot be parsed.
+
− */
+
−static T_SOCK_IPADDR inet_aton(char *addr_string)
+
−{
+
−  T_SOCK_IPADDR ipaddr ;
+
−  U8 *addrbyte ;
+
−  int o1, o2, o3, o4 ;
+
−
+
−  if (sscanf(addr_string, "%d.%d.%d.%d", &o1, &o2, &o3, &o4) != 4)
+
−  {
+
−    TRACE_EVENT_P1("cannot parse '%s' as an IP address", addr_string) ;
+
−    return SOCK_IPADDR_ANY ;
+
−  }
+
−  addrbyte = (U8 *) &ipaddr ;
+
−  addrbyte[0] = (U8) o1 ;
+
−  addrbyte[1] = (U8) o2 ;
+
−  addrbyte[2] = (U8) o3 ;
+
−  addrbyte[3] = (U8) o4 ;
+
−
+
−  return ipaddr ;
+
−}
+
−
+
−
+
−LOCAL char *sock_result_string(T_SOCK_RESULT result)
+
−{
+
−  switch(result)
+
−  {
+
−    case SOCK_RESULT_OK                : return "SOCK_RESULT_OK";
+
−    case SOCK_RESULT_INVALID_PARAMETER : return "SOCK_RESULT_INVALID_PARAMETER"; 
+
−    case SOCK_RESULT_INTERNAL_ERROR    : return "SOCK_RESULT_INTERNAL_ERROR";
+
−    case SOCK_RESULT_ADDR_IN_USE       : return "SOCK_RESULT_ADDR_IN_USE";
+
−    case SOCK_RESULT_OUT_OF_MEMORY     : return "SOCK_RESULT_OUT_OF_MEMORY";
+
−    case SOCK_RESULT_NOT_SUPPORTED     : return "SOCK_RESULT_NOT_SUPPORTED";
+
−    case SOCK_RESULT_UNREACHABLE       : return "SOCK_RESULT_UNREACHABLE";
+
−    case SOCK_RESULT_CONN_REFUSED      : return "SOCK_RESULT_CONN_REFUSED";
+
−    case SOCK_RESULT_TIMEOUT           : return "SOCK_RESULT_TIMEOUT";
+
−    case SOCK_RESULT_IS_CONNECTED      : return "SOCK_RESULT_IS_CONNECTED";
+
−    case SOCK_RESULT_HOST_NOT_FOUND    : return "SOCK_RESULT_HOST_NOT_FOUND";
+
−    case SOCK_RESULT_DNS_TEMP_ERROR    : return "SOCK_RESULT_DNS_TEMP_ERROR";
+
−    case SOCK_RESULT_DNS_PERM_ERROR    : return "SOCK_RESULT_DNS_PERM_ERROR";
+
−    case SOCK_RESULT_NO_IPADDR         : return "SOCK_RESULT_NO_IPADDR";
+
−    case SOCK_RESULT_NOT_CONNECTED     : return "SOCK_RESULT_NOT_CONNECTED";
+
−    case SOCK_RESULT_MSG_TOO_BIG       : return "SOCK_RESULT_MSG_TOO_BIG";
+
−    case SOCK_RESULT_CONN_RESET        : return "SOCK_RESULT_CONN_RESET";
+
−    case SOCK_RESULT_CONN_ABORTED      : return "SOCK_RESULT_CONN_ABORTED";
+
−    case SOCK_RESULT_NO_BUFSPACE       : return "SOCK_RESULT_NO_BUFSPACE";
+
−    case SOCK_RESULT_NETWORK_LOST      : return "SOCK_RESULT_NETWORK_LOST";
+
−    case SOCK_RESULT_NOT_READY         : return "SOCK_RESULT_NOT_READY";
+
−    case SOCK_RESULT_BEARER_NOT_READY  : return "SOCK_RESULT_BEARER_NOT_READY";
+
−    case SOCK_RESULT_IN_PROGRESS       : return "SOCK_RESULT_IN_PROGRESS";
+
−    case SOCK_RESULT_BEARER_ACTIVE     : return "SOCK_RESULT_BEARER_ACTIVE";
+
−    default                            : return "<INVALID SOCKET RESULT!>";
+
−  }
+
−}
+
−
+
−
+
−
+
−/** Trace a specific socket API result code with some context.
+
− *
+
− * @param pcont        Pointer to process context.
+
− * @param function     The function or event that reported the error.
+
− * @param result       Socket API result code.
+
− * @return
+
− */
+
−static void sock_trace_result(PROC_CONTEXT_T *pcont, char *function,
+
−                              T_SOCK_RESULT result)
+
−{
+
−  if(result NEQ SOCK_RESULT_OK)
+
−  {
+
−    TRACE_ERROR("Sock Result Error");
+
−  }
+
−  TRACE_EVENT_P3("%s: %s for %s", function, 
+
−                 sock_result_string(result), proc_string(pcont));
+
−}
+
−
+
−
+
−/** Return the string for a Socket API event type. We don't have the values
+
− * under our (i. e. APP's) own control, so we rather do a switch than indexing
+
− * an array.
+
− *
+
− * @param event_type    Type of the event.
+
− * @return              String for the event type.
+
− */
+
−char *sock_event_string(T_SOCK_EVENTTYPE event_type)
+
−{
+
−  switch (event_type)
+
−  {
+
−    case SOCK_CREATE_CNF:        return "SOCK_CREATE_CNF" ;
+
−    case SOCK_CLOSE_CNF:         return "SOCK_CLOSE_CNF" ;
+
−    case SOCK_BIND_CNF:          return "SOCK_BIND_CNF" ;
+
−    case SOCK_LISTEN_CNF:        return "SOCK_LISTEN_CNF" ;
+
−    case SOCK_CONNECT_CNF:       return "SOCK_CONNECT_CNF" ;
+
−    case SOCK_SOCKNAME_CNF:      return "SOCK_SOCKNAME_CNF" ;
+
−    case SOCK_PEERNAME_CNF:      return "SOCK_PEERNAME_CNF" ;
+
−    case SOCK_HOSTINFO_CNF:      return "SOCK_HOSTINFO_CNF" ;
+
−    case SOCK_MTU_SIZE_CNF:      return "SOCK_MTU_SIZE_CNF" ;
+
−    case SOCK_RECV_IND:          return "SOCK_RECV_IND" ;
+
−    case SOCK_CONNECT_IND:       return "SOCK_CONNECT_IND" ;
+
−    case SOCK_CONN_CLOSED_IND:   return "SOCK_CONN_CLOSED_IND" ;
+
−    case SOCK_ERROR_IND:         return "SOCK_ERROR_IND" ;
+
−    case SOCK_FLOW_READY_IND:    return "SOCK_FLOW_READY_IND" ;
+
−    case SOCK_OPEN_BEARER_CNF:   return "SOCK_OPEN_BEARER_CNF";
+
−    case SOCK_CLOSE_BEARER_CNF:  return "SOCK_CLOSE_BEARER_CNF";
+
−    case SOCK_BEARER_INFO_CNF:   return "SOCK_BEARER_INFO_CNF";
+
−    case SOCK_BAERER_CLOSED_IND: return "SOCK_BAERER_CLOSED_IND";
+
−    default:                     return "<INVALID EVENT>" ;
+
−  }
+
−}
+
−
+
−
+
−
+
−/*
+
− * Process functions.
+
− */
+
−
+
−static void proc_shutdown(PROC_CONTEXT_T *pcont) ;
+
−static void proc_close_socket(PROC_CONTEXT_T *pcont) ;
+
−static void proc_begin_comm(PROC_CONTEXT_T *pcont) ;
+
−static void proc_close_conn(PROC_CONTEXT_T *pcont) ;
+
−
+
−
+
−/** Switch process to a new state. Done mostly to have a single place to trace
+
− * process state transitions.
+
− *
+
− * @param pcont       Pointer to process context.
+
− * @param newstate    New state of process.
+
− */
+
−static void proc_new_state(PROC_CONTEXT_T *pcont, PROC_STAT_T newstate)
+
−{
+
−  if (newstate < PS_INVALID)
+
−  {
+
−    TRACE_EVENT_P2("%s -> %s", proc_string(pcont), proc_state_name[newstate]) ;
+
−    pcont->pstate = newstate ;
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT_P2("%s invalid new state %d", proc_string(pcont), newstate) ;
+
−    proc_shutdown(pcont) ;
+
−  }
+
−}
+
−
+
−
+
−/** Fork a new TCP server process context to handle a TCP client. Return a
+
− * pointer to the process context or NULL, if no process context is free any
+
− * more.
+
− *
+
− */
+
−static PROC_CONTEXT_T *proc_new_tcpfork(PROC_CONTEXT_T *oldp)
+
−{
+
−    int i ;
+
−    PROC_CONTEXT_T *pcont ;
+
−
+
−    TRACE_FUNCTION("proc_new_tcpfork()") ;
+
−    for (i = 0; i < APP_N_CLIENTS; i++)
+
−    {
+
−        if (cl_context[i].ptype EQ AP_NONE)
+
−        {
+
−            break ;
+
−        }
+
−    }
+
−    if (i == APP_N_CLIENTS)
+
−    {
+
−        return NULL ;
+
−    }
+
−
+
−    pcont = &cl_context[i] ;
+
−    memset(pcont, 0, sizeof(*pcont)) ;
+
−    pcont->f_id = i ;
+
−    pcont->ptype = AP_TCPFORK ;
+
−    pcont->pstate = PS_IDLE ;
+
−    pcont->ipproto = oldp->ipproto ;
+
−    pcont->server_name = oldp->server_name ;
+
−    pcont->server_ipaddr = oldp->server_ipaddr ;
+
−    pcont->server_port = oldp->server_port ;
+
−    pcont->network_is_open = TRUE ;
+
−    pcont->psocket_is_open = TRUE ;
+
−
+
−    return pcont ;
+
−}
+
−
+
−/** Free a TCP server process context.
+
− *
+
− */
+
−static void proc_free_tcpfork(PROC_CONTEXT_T *pcont)
+
−{
+
−    TRACE_FUNCTION("proc_free_tcpfork()") ;
+
−    proc_new_state(pcont, PS_IDLE) ;
+
−    memset(pcont, 0, sizeof(*pcont)) ;
+
−}
+
−
+
−
+
−static void proc_init(int prov, int size, int reps, APP_PROCTYPE_T ptype,
+
−                      T_SOCK_IPPROTO ipproto, U16 port)
+
−{
+
−  T_SOCK_BEARER_INFO bearer_info;
+
−  PROC_CONTEXT_T *pcont ;
+
−  BOOL bear_only = proc_context.bearer_only;
+
−
+
−  TRACE_FUNCTION("proc_init()") ;
+
−
+
−  pcont = &proc_context ;
+
−  if (pcont->pstate != PS_IDLE)
+
−  {
+
−    TRACE_ERROR("proc_init: process still active") ;
+
−    return ;
+
−  }
+
−  memset(pcont, 0, sizeof(*pcont)) ;
+
−  pcont->bearer_only = bear_only;
+
−  pcont->ptype = ptype ;
+
−  pcont->ipproto = ipproto ;
+
−  pcont->server_name = (ptype EQ AP_TCPSRV) ? "<myself>" : server_name ;
+
−  pcont->server_ipaddr = (ptype EQ AP_TCPSRV) ?
+
−    SOCK_IPADDR_ANY : inet_aton(pcont->server_name) ;
+
−  pcont->server_port = HTONS(port) ;
+
−  pcont->spec_items = size ;
+
−  pcont->spec_reps = reps ;
+
−  pcont->in_shutdown = FALSE;
+
−
+
−  pcont->psocket = 0;
+
−  pcont->network_is_open = FALSE;
+
−  pcont->psocket_is_open = FALSE;
+
−
+
−  TRACE_EVENT_P7("%s for %d bytes %d reps, server %s:%d/%s on %s",
+
−                 proc_string(pcont), pcont->spec_items, pcont->spec_reps,
+
−                 inet_ntoa(pcont->server_ipaddr), NTOHS(pcont->server_port),
+
−                 (ipproto EQ SOCK_IPPROTO_UDP) ? "udp" : "tcp",
+
−                 sock_bearer_type_string(sock_bearer_type)) ;
+
−  app_pstat();
+
−
+
−  // fill connection params
+
−  bearer_info.bearer_handle = sock_bearer_handle;
+
−  bearer_info.app_handle    = APP_handle;
+
−  bearer_info.bearer_type   = sock_bearer_type;
+
−
+
−  if(sock_bearer_type == SOCK_BEARER_GPRS)
+
−  {
+
−    bearer_info.apn_valid = TRUE;
+
−    bearer_info.phone_nr_valid = FALSE;
+
−    bearer_info.cid = 1;
+
−
+
−    switch(prov)
+
−    {
+
−      case APP_PROV_T_MOBILE:
+
−        strcpy(bearer_info.apn, "internet.t-d1.de");
+
−        strcpy(bearer_info.user_id, "t-d1");
+
−        strcpy(bearer_info.password, "gprs");
+
−        break;
+
−
+
−      case APP_PROV_HUTCH:
+
−        strcpy(bearer_info.apn, "www");
+
−        strcpy(bearer_info.user_id, "");
+
−        strcpy(bearer_info.password, "");
+
−        break;
+
−
+
−      case APP_PROV_AIRTEL:
+
−        strcpy(bearer_info.apn, "airtelgprs.com");
+
−        strcpy(bearer_info.user_id, "");
+
−        strcpy(bearer_info.password, "");
+
−        break;
+
−
+
−      case APP_PROV_CUSTOM:
+
−        /* Copy valid APN */
+
−        if(custom_apn_valid)
+
−        {
+
−          strcpy(bearer_info.apn, custom_apn);
+
−          strcpy(bearer_info.user_id, custom_user_id);
+
−          strcpy(bearer_info.password, custom_password);
+
−          break;
+
−        }
+
−        /* Copy default settings for invalid APN settings */
+
−	
+
−      default:
+
−        strcpy(bearer_info.apn,"web.vodafone.de");
+
−        strcpy(bearer_info.user_id, "");
+
−        strcpy(bearer_info.password, "");
+
−        break;
+
−    }
+
−  }
+
−  else
+
−  {
+
−    bearer_info.phone_nr_valid = TRUE;
+
−    bearer_info.apn_valid = FALSE;
+
−    bearer_info.cid = 0;
+
−    if(prov == APP_PROV_T_MOBILE)
+
−    {
+
−      strcpy(bearer_info.phone_nr, "+491712524120");
+
−      strcpy(bearer_info.user_id, "t-d1");
+
−      strcpy(bearer_info.password, "wap");
+
−    }
+
−    else
+
−    {
+
−      strcpy(bearer_info.phone_nr, "+491722290000");
+
−      strcpy(bearer_info.user_id, "");
+
−      strcpy(bearer_info.password, "");
+
−    }
+
−  }
+
−  bearer_info.user_id_valid = TRUE;
+
−  bearer_info.password_valid = TRUE;
+
−
+
−  bearer_info.ip_address = SOCK_IPADDR_ANY;
+
−  bearer_info.dns1 = SOCK_IPADDR_ANY;
+
−  bearer_info.dns2 = SOCK_IPADDR_ANY;
+
−  bearer_info.gateway = SOCK_IPADDR_ANY;
+
−  bearer_info.authtype = SOCK_AUTH_NO;
+
−  bearer_info.data_compr = FALSE;
+
−  bearer_info.header_comp = FALSE;
+
−  bearer_info.precedence = 0;
+
−  bearer_info.delay = 0;
+
−  bearer_info.reliability = 0;
+
−  bearer_info.peak_throughput = 0;
+
−  bearer_info.mean_througput = 0;
+
−  bearer_info.shareable = FALSE;
+
−
+
−  sock_open_bearer(sock_api_inst,bearer_select,0,&bearer_info,app_sock_callback,pcont);
+
−  if(pcont->bearer_only)
+
−  {
+
−    proc_new_state(pcont, PS_W_DCM_OPEN_ONLY) ;
+
−  }
+
−  else
+
−  {
+
−    proc_new_state(pcont, PS_W_DCM_OPEN) ;
+
−  }
+
−}
+
−
+
−
+
−static void proc_client_closed(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_RESULT result ;
+
−  TRACE_FUNCTION("proc_client_closed()") ;
+
−  
+
−  result = sock_close(pcont->psocket);
+
−  if (result != SOCK_RESULT_OK)
+
−  {
+
−    TRACE_EVENT_P1("%s: error closing client socket", proc_string(pcont)) ;
+
−    proc_shutdown(pcont) ;
+
−    return;
+
−  }
+
−  proc_free_tcpfork(pcont) ;
+
−}
+
−
+
−
+
−
+
−/***********************************************************************
+
− * Communication functions.
+
− */
+
−
+
−
+
−/** Fill and send data buffer.
+
− *
+
− * @param pcont        Pointer to process context.
+
− * @param size         Size of data buffer.
+
− * @return
+
− */
+
−static BOOL comm_send_buffer(PROC_CONTEXT_T *pcont, int size)
+
−{
+
−  char *payload ;               /* Pointer to payload buffer. */
+
−  char *cp ;                    /* Pointer into paylaod buffer. */
+
−  char *pp ;                    /* Pointer into test pattern. */
+
−  T_SOCK_RESULT result ;        /* Result of send call. */
+
−
+
−  TRACE_FUNCTION("comm_send_buffer()") ;
+
−  MALLOC(payload, size) ;
+
−  TRACE_EVENT_P1("PALLOC payload %x", payload) ;
+
−  /* Fill buffer with pattern. */
+
−  for (cp = payload, pp = APP_SEND_PATTERN; cp < payload + size; cp++, pp++)
+
−  {
+
−    if (pp >= APP_SEND_PATTERN + sizeof(APP_SEND_PATTERN) - 1)
+
−    {
+
−      pp = APP_SEND_PATTERN ;
+
−    }
+
−    *cp = *pp ;
+
−  }
+
−  if(pcont->ipproto == SOCK_IPPROTO_UDP)
+
−  {
+
−    // use UDP socket and specify destination IP address and destination port
+
−    result = sock_sendto(pcont->psocket, payload, (U16)size,
+
−                         pcont->server_ipaddr,pcont->server_port) ;
+
−  }
+
−  else
+
−  {
+
−    result = sock_send(pcont->psocket, payload, (U16)size) ;
+
−  }
+
−  sock_trace_result(pcont, "sock_send()", result) ;
+
−  MFREE(payload) ;
+
−  switch (result)
+
−  {
+
−    case SOCK_RESULT_OK:
+
−      TRACE_EVENT_P6("%s sent %d (%d/%d) bytes in rep %d/%d",
+
−                     proc_string(pcont), size, pcont->data_sent,
+
−                     pcont->spec_items,
+
−                     //* ((pcont->ipproto EQ SOCK_IPPROTO_TCP) ? 1 : size),
+
−                     pcont->n_reps, pcont->spec_reps) ;
+
−      return TRUE ;
+
−    case SOCK_RESULT_NO_BUFSPACE:
+
−      return FALSE ;            /* Pause until SOCK_FLOW_READY_IND. */
+
−    default:
+
−      proc_shutdown(pcont) ;
+
−      return FALSE ;
+
−  }
+
−}
+
−
+
−
+
−/** Server: send some data to the client.
+
− *
+
− * @param pcont        Pointer to process context.
+
− * @return
+
− */
+
−static BOOL comm_send_srvprompt(PROC_CONTEXT_T *pcont)
+
−{
+
−  char *payload ;               /* Pointer to payload buffer. */
+
−  int size ;                    /* Actual size of payload. */
+
−  T_SOCK_RESULT result ;        /* Result of send call. */
+
−  TRACE_FUNCTION("comm_send_srv()") ;
+
−
+
−  MALLOC(payload, 600) ;
+
−  sprintf(payload, "%s: %sin_shutdown, last_evt %s, will %srepeat\n",
+
−          proc_string(pcont), pcont->in_shutdown ? "" : "not ",
+
−          pcont->last_evt
+
−          ? sock_event_string(pcont->last_evt->event_type) : "NULL",
+
−          pcont->spec_reps ? "" : "not ") ;
+
−  sprintf(payload + strlen(payload),
+
−          "    rx %d B %d pkts, tx %d B %d pkts, errs %d conn %d\n",
+
−          pcont->data_rcvd, pcont->items_rcvd,
+
−          pcont->data_sent, pcont->items_sent,
+
−          pcont->errors, pcont->n_reps) ;
+
−
+
−  size = strlen(payload) ;
+
−  result = sock_send(pcont->psocket, payload, (U16)size) ;
+
−  sock_trace_result(pcont, "sock_send()", result) ;
+
−  MFREE(payload) ;
+
−  switch (result)
+
−  {
+
−    case SOCK_RESULT_OK:
+
−      pcont->data_sent += size ;
+
−      pcont->items_sent++ ;
+
−      TRACE_EVENT_P5("%s sent %d (%d/%d) bytes in conn %d",
+
−                     proc_string(pcont), size, pcont->data_sent,
+
−                     pcont->spec_items * size,
+
−                     pcont->n_reps) ;
+
−      return TRUE ;
+
−    case SOCK_RESULT_NO_BUFSPACE:
+
−      return FALSE ;            /* Pause until SOCK_FLOW_READY_IND. */
+
−    default:
+
−      proc_shutdown(pcont) ;
+
−      return FALSE ;
+
−  }
+
−}
+
−
+
−
+
−/** Issue a DNS query. Called for AP_DNSQRY in state PS_COMM.
+
− *
+
− * @param pcont        Pointer to process context.
+
− */
+
−static void comm_query(PROC_CONTEXT_T *pcont)
+
−{
+
−  static int next_query = 0 ;   /* Next query index. */
+
−  char *name ;                  /* Domain name to query for. */
+
−  T_SOCK_RESULT result ;        /* Result of query call. */
+
−
+
−  TRACE_FUNCTION("comm_query()") ;
+
−  if (query_name[0])
+
−  {
+
−    name = query_name ;
+
−  }
+
−  else
+
−  {
+
−    name = domain_name[next_query] ;
+
−  }
+
−  TRACE_EVENT_P4("%s: query (%d/%d) for %s", proc_string(pcont),
+
−                 pcont->items_sent + 1, pcont->spec_items, name) ;
+
−  result = sock_gethostbyname(sock_api_inst, name, app_sock_callback, pcont) ;
+
−  sock_trace_result(pcont, "sock_gethostbyname()", result) ;
+
−  if (result != SOCK_RESULT_OK)
+
−  {
+
−    pcont->errors++ ;
+
−    TRACE_ERROR("sock_gethostbyname() failed, sleep...") ;
+
−    vsi_t_sleep(VSI_CALLER 2000) ;
+
−  }
+
−
+
−  if (!domain_name[++next_query])
+
−  {
+
−    next_query = 0 ;
+
−  }
+
−  pcont->items_sent++ ;
+
−}
+
−
+
−
+
−
+
−/** Send data. Called for all but AP_DNSQRY in state PS_COMM.
+
− *
+
− * @param pcont        Pointer to process context.
+
− */
+
−static void comm_send(PROC_CONTEXT_T *pcont)
+
−{
+
−  TRACE_EVENT_P1("comm_send() %s", proc_string(pcont)) ;
+
−
+
−  switch (pcont->ptype)
+
−  {
+
−    case AP_TCPDL:
+
−      /* Do nothing -- the server will send again anyway. */
+
−      return ;
+
−    case AP_UDPDL:
+
−      if (pcont->data_sent >= pcont->spec_items)
+
−      {
+
−        return;
+
−      }
+
−      break;
+
−    case AP_TCPUL:
+
−    case AP_UDPUL:
+
−      if (pcont->data_sent >= pcont->spec_items)
+
−      {
+
−        TRACE_EVENT_P2("%s done after %d bytes",
+
−                       proc_string(pcont), pcont->data_sent) ;
+
−        proc_close_socket(pcont) ;
+
−        pcont->n_reps++ ;
+
−        return ;
+
−      }
+
−      break ;
+
−    case AP_TCPECHO:
+
−    case AP_UDPECHO:
+
−      if (pcont->items_sent >= pcont->spec_items)
+
−      {
+
−        TRACE_EVENT_P2("%s done after %d writes",
+
−                       proc_string(pcont), pcont->items_sent) ;
+
−        proc_close_socket(pcont) ;
+
−        pcont->n_reps++ ;
+
−        return ;
+
−      }
+
−      break ;
+
−    case AP_DNSQRY:
+
−      comm_query(pcont) ;
+
−      return ;
+
−    case AP_TCPFORK:             /* Send some data, perhaps. */
+
−      switch (pcont->server_port)
+
−      {
+
−        case PORT_CHARGEN:      /* Send something (below). */
+
−          break ;
+
−        case PORT_ECHO:         /* Send somewhere else. */
+
−        case PORT_DISCARD:      /* Don't send anything. */
+
−          return ;
+
−        default:                /* Send a server prompt. */
+
−          comm_send_srvprompt(pcont) ;
+
−          break ;
+
−      }
+
−      return ;
+
−    case AP_NONE:
+
−    case AP_INVALID:
+
−    default:
+
−      TRACE_EVENT_P1("Invalid process type %s", proc_string(pcont)) ;
+
−      return ;
+
−  }
+
−
+
−  if (comm_send_buffer(pcont, buffer_size))
+
−  {
+
−    pcont->items_sent++ ;
+
−    TRACE_EVENT_P1("Sent Items: %u",pcont->items_sent);
+
−    pcont->data_sent += buffer_size ;
+
−    vsi_t_sleep(VSI_CALLER udp_interval);
+
−  }
+
−  else
+
−  {
+
−    if (pcont->ptype EQ AP_UDPUL)
+
−    {
+
−      TRACE_EVENT_P2("%s sleeps %d ms", proc_string(pcont), udp_interval) ;
+
−      vsi_t_sleep(VSI_CALLER udp_interval);
+
−    }
+
−  }
+
−}
+
−
+
−
+
−/** Handle an incoming DNS result. Called for AP_DNSQRY in state PS_COMM.
+
− *
+
− * @param pcont        Pointer to process context.
+
− */
+
−static void comm_dns_result(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_HOSTINFO_CNF *hinfo ;
+
−
+
−  TRACE_FUNCTION("comm_dns_result()") ;
+
−  pcont->items_rcvd++ ;
+
−
+
−  hinfo = (T_SOCK_HOSTINFO_CNF *) pcont->last_evt ;
+
−  if (hinfo->result != SOCK_RESULT_OK)
+
−  {
+
−    TRACE_EVENT_P3("lookup error %d in %d/%d queries",
+
−                   pcont->errors, pcont->items_rcvd, pcont->spec_items) ;
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT_P1("Answer for host %s", hinfo->hostname) ;
+
−    TRACE_EVENT_P3("has address %s (%d/%d)",
+
−                   inet_ntoa(hinfo->ipaddr),
+
−                   pcont->items_rcvd, pcont->spec_items) ;
+
−  }
+
−  if (pcont->items_rcvd < pcont->spec_items)
+
−  {
+
−    comm_send(pcont) ;
+
−  }
+
−  else
+
−  {
+
−    proc_close_conn(pcont) ;
+
−  }
+
−}
+
−
+
−
+
−/** Receive incoming data. Called for all but AP_TCPUL in state PS_COMM.
+
− *
+
− * @param pcont        Pointer to process context.
+
− */
+
−static void comm_recv(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_RECV_IND *recv_ind = (T_SOCK_RECV_IND *) pcont->last_evt ;
+
−
+
−  TRACE_FUNCTION("comm_recv()") ;
+
−  if (pcont->ptype EQ AP_DNSQRY OR pcont->ptype EQ AP_TCPUL)
+
−  {
+
−    TRACE_EVENT_P2("%s: %s unexpected for ptype", proc_string(pcont),
+
−                   sock_event_string(pcont->last_evt->event_type)) ;
+
−    proc_shutdown(pcont) ;
+
−    return ;
+
−  }
+
−  pcont->data_rcvd += recv_ind->data_length ;
+
−  pcont->items_rcvd++ ;
+
−  TRACE_EVENT_P5("%s: recv #%d:%u bytes, total %u, total items sent:%u", proc_string(pcont),
+
−                 pcont->items_rcvd, recv_ind->data_length, pcont->data_rcvd,pcont->items_sent);
+
−  trace_dump_data((U8 *) recv_ind->data_buffer,
+
−                  MIN(APP_DATA_DUMP_LENGTH, recv_ind->data_length)) ;
+
−  MFREE(recv_ind->data_buffer) ;
+
−  recv_ind->data_buffer = 0 ;
+
−  switch (pcont->ptype)
+
−  {
+
−    case AP_UDPDL:
+
−      /* After every sent UDP packet, a "answer" comes from the Chargen server. 
+
−       * If all packets are sent we are waiting for the last packet to 
+
−       * receive, else an unexpected event would be the result in the 
+
−       * "app_sock_callback()"; TCPIP_DATA_IND is received instead of SOCK_CLOSE_CNF
+
−       * TODO: why (pcont->items_sent-1), I assume that the server "confirms"
+
−       *       every packet
+
−       */
+
−      if ((pcont->data_sent >= pcont->spec_items) &&
+
−          (pcont->items_rcvd == pcont->items_sent))
+
−      {
+
−        TRACE_EVENT("last UDP-DL packet received");
+
−        pcont->n_reps++ ;
+
−        proc_close_socket(pcont) ;
+
−      }
+
−      else {
+
−        comm_send(pcont);
+
−      }
+
−      break;
+
−    case AP_TCPDL:
+
−      if (pcont->data_rcvd >= pcont->spec_items)
+
−      {
+
−        TRACE_EVENT_P3("%s done after %d/%d bytes",
+
−                       proc_string(pcont), pcont->data_rcvd,
+
−                       pcont->spec_items) ;
+
−        pcont->n_reps++ ;
+
−        proc_close_socket(pcont) ;
+
−      }
+
−      break ;
+
−    case AP_UDPECHO:
+
−    case AP_TCPECHO:
+
−    case AP_TCPFORK:
+
−      comm_send(pcont) ;
+
−      break ;
+
−    default:
+
−      TRACE_ERROR("Unexpected ptype in comm_recv()") ;
+
−      break ;
+
−  }
+
−}
+
−
+
−
+
−/** Handle a communication event according to the process type. Called for all
+
− * process types in state PS_COMM.
+
− *
+
− * @param pcont        Pointer to process context.
+
− */
+
−static void comm_event(PROC_CONTEXT_T *pcont)
+
−{
+
−  TRACE_FUNCTION("comm_event()") ;
+
−
+
−  switch (pcont->last_evt->event_type)
+
−  {
+
−    case SOCK_CONN_CLOSED_IND:
+
−      if (pcont->ptype EQ AP_TCPFORK)
+
−      {
+
−        proc_client_closed(pcont) ;
+
−        break ;
+
−      }
+
−      /*lint -fallthrough */
+
−    case SOCK_ERROR_IND:
+
−      TRACE_EVENT_P2("%s: %s, shutdown", proc_string(pcont),
+
−                     sock_event_string(pcont->last_evt->event_type)) ;
+
−      // server should not reset , even if connection is reset by client.
+
−      // but client should shutdown , if connection is reset by server.
+
−      if((pcont->ptype EQ AP_TCPFORK)  AND
+
−         (pcont->last_evt->result == SOCK_RESULT_CONN_RESET OR
+
−          pcont->last_evt->result == SOCK_RESULT_TIMEOUT))
+
−      {
+
−         proc_client_closed(pcont) ;
+
−         return;
+
−      }
+
−      else
+
−        proc_shutdown(pcont) ;
+
−      return ;
+
−    case SOCK_RECV_IND:
+
−      comm_recv(pcont) ;
+
−      break ;
+
−    case SOCK_FLOW_READY_IND:
+
−      if(pcont->ptype NEQ AP_UDPDL) {
+
−        comm_send(pcont) ;
+
−      }
+
−      break ;
+
−    case SOCK_HOSTINFO_CNF:
+
−      if (pcont->ptype EQ AP_DNSQRY) {
+
−        comm_dns_result(pcont) ;
+
−        break ;
+
−      }
+
−      /*lint -fallthrough */
+
−    case SOCK_CREATE_CNF:
+
−    case SOCK_CLOSE_CNF:
+
−    case SOCK_BIND_CNF:
+
−    case SOCK_LISTEN_CNF:
+
−    case SOCK_CONNECT_CNF:
+
−    case SOCK_SOCKNAME_CNF:
+
−    case SOCK_PEERNAME_CNF:
+
−    case SOCK_MTU_SIZE_CNF:
+
−    case SOCK_CONNECT_IND:
+
−      TRACE_EVENT_P2("%s: %s unexpected at all", proc_string(pcont),
+
−                     sock_event_string(pcont->last_evt->event_type)) ;
+
−      proc_shutdown(pcont) ;
+
−      return ;
+
−    case SOCK_BAERER_CLOSED_IND:
+
−      proc_shutdown(pcont);
+
−      break;
+
−    default:
+
−      TRACE_EVENT_P2("comm_event(): %s unknown event %d",
+
−                     proc_string(pcont), pcont->last_evt->event_type) ;
+
−      proc_shutdown(pcont) ;
+
−      break ;
+
−  }
+
−}
+
−
+
−
+
−
+
−/***********************************************************************
+
− * State machine functions (i. e. state-changing functions)
+
− */
+
−
+
−/** Finish the process after the network connection has been closed.
+
− *
+
− * @param pcont       Pointer to process context.
+
− */
+
−static void proc_finish(PROC_CONTEXT_T *pcont)
+
−{
+
−  TRACE_EVENT_P1("%s finished", proc_string(pcont)) ;
+
−  pcont->network_is_open = FALSE ;
+
−  pcont->in_shutdown = FALSE;
+
−  proc_new_state(pcont, PS_IDLE) ;
+
−}
+
−
+
−
+
−/** Shutdown process hard, usually after an error or user request. This
+
− * includes closing the process's socket and network connection.
+
− *
+
− * @param pcont       Pointer to process context.
+
− */
+
−static void proc_shutdown(PROC_CONTEXT_T *pcont)
+
−{
+
−  TRACE_FUNCTION("proc_shutdown()") ;
+
−
+
−  if(pcont->in_shutdown)
+
−  {
+
−    TRACE_EVENT("Allready in shutdown");
+
−    return;
+
−  }
+
−  pcont->in_shutdown = TRUE ;
+
−  app_pstat() ;
+
−  if (pcont->psocket_is_open)
+
−  {
+
−    proc_close_socket(pcont);
+
−    return;
+
−  }
+
−  if (pcont->network_is_open OR
+
−      pcont->pstate == PS_W_DCM_OPEN OR pcont->pstate == PS_W_DCM_OPEN_ONLY)
+
−  {
+
−    proc_close_conn(pcont);
+
−    return;
+
−  }
+
−  else
+
−  {
+
−    proc_finish(pcont);
+
−  }
+
−}
+
−
+
−
+
−/** Create a socket after the network connection has been established.
+
− *
+
− * @param pcont       Pointer to process context.
+
− */
+
−static void proc_open_socket(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_RESULT result ;
+
−
+
−  TRACE_FUNCTION("proc_open_socket()") ;
+
−  /* We don't need to do this for the DNS query process. */
+
−  if (pcont->ptype EQ AP_DNSQRY)
+
−  {
+
−    proc_begin_comm(pcont) ;
+
−  }
+
−  else
+
−  {
+
−    result = sock_create(sock_api_inst, pcont->ipproto, app_sock_callback, pcont);
+
−    if (result NEQ SOCK_RESULT_OK)
+
−    {
+
−      sock_trace_result(pcont, "sock_create()", result) ;
+
−      proc_shutdown(pcont) ;
+
−      return;
+
−    }
+
−    proc_new_state(pcont, PS_W_CREAT) ;
+
−  }
+
−}
+
−
+
−
+
−/** Close the network connection after the task has been done.
+
− *
+
− * @param pcont       Pointer to process context.
+
− */
+
−static void proc_close_conn(PROC_CONTEXT_T *pcont)
+
−{
+
−  
+
−
+
−  TRACE_FUNCTION("proc_close_conn()");
+
−  if(pcont->network_is_open)
+
−  {
+
−    pcont->in_shutdown = TRUE;
+
−    sock_close_bearer(sock_api_inst, sock_bearer_handle, app_sock_callback, pcont);
+
−    proc_new_state(pcont, PS_W_DCLOS) ;
+
−  }
+
−  else
+
−  {
+
−    proc_finish(pcont);
+
−  }
+
−}
+
−
+
−
+
−/** Connect the socket after it has been created.
+
− *
+
− * @param pcont       Pointer to process context.
+
− */
+
−static void proc_connect_socket(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_RESULT result ;
+
−
+
−  TRACE_FUNCTION("proc_connect_socket()") ;
+
−  /* If we do not yet have an IP address to connect to, look it up first. */
+
−  if (pcont->server_ipaddr EQ SOCK_IPADDR_ANY)
+
−  {
+
−    result = sock_gethostbyname(sock_api_inst, pcont->server_name,app_sock_callback, pcont);
+
−    if (result NEQ SOCK_RESULT_OK)
+
−    {
+
−      sock_trace_result(pcont, "sock_gethostbyname()", result) ;
+
−      proc_shutdown(pcont) ;
+
−      return;
+
−    }
+
−    proc_new_state(pcont, PS_W_DNS) ;
+
−    return ;
+
−  }
+
−
+
−  result = sock_connect(pcont->psocket, pcont->server_ipaddr, pcont->server_port);
+
−  if (result NEQ SOCK_RESULT_OK)
+
−  {
+
−    sock_trace_result(pcont, "sock_connect()", result) ;
+
−    proc_shutdown(pcont) ;
+
−    return;
+
−  }
+
−  proc_new_state(pcont, PS_W_SCONN) ;
+
−}
+
−
+
−
+
−/** Begin communicating after the socket has been created.
+
− *
+
− * @param pcont       Pointer to process context.
+
− */
+
−static void proc_begin_comm(PROC_CONTEXT_T *pcont)
+
−{
+
−  TRACE_FUNCTION("proc_begin_comm()") ;
+
−
+
−  proc_new_state(pcont, PS_COMM) ;
+
−  switch (pcont->ptype)
+
−  {
+
−    case AP_TCPDL:
+
−      /* We wait for data from the server to arrive. */
+
−      break ;
+
−    case AP_UDPDL:
+
−      /* Trigger the chargen server to send fisrt UDP packet */
+
−       comm_send(pcont);
+
−      break ;
+
−    case AP_TCPUL:
+
−    case AP_UDPUL:
+
−    case AP_TCPECHO:
+
−    case AP_UDPECHO:
+
−    case AP_DNSQRY:
+
−    case AP_TCPFORK:
+
−      comm_send(pcont) ;
+
−      break ;
+
−    default:
+
−      TRACE_EVENT_P2("%s unknown state (%d)",
+
−                     proc_string (pcont), pcont->ptype) ;
+
−      break ;
+
−  }
+
−}
+
−
+
−
+
−/** Close the socket after the requested communication has been done.
+
− *
+
− * @param pcont       Pointer to process context.
+
− */
+
−static void proc_close_socket(PROC_CONTEXT_T *pcont)
+
−{
+
−  TRACE_FUNCTION("proc_close_socket()") ;
+
−
+
−  sock_close(pcont->psocket) ;
+
−  proc_new_state(pcont, PS_W_SCLOS) ;
+
−}
+
−
+
−
+
−static void proc_bind_socket(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_RESULT result ;
+
−  TRACE_FUNCTION("proc_bind_socket()") ;
+
−
+
−  if ((result = sock_bind(pcont->psocket, pcont->server_port))
+
−      != SOCK_RESULT_OK)
+
−  {
+
−    sock_trace_result(pcont, "sock_bind()", result) ;
+
−    proc_shutdown(pcont) ;
+
−    return;
+
−  }
+
−  proc_new_state(pcont, PS_W_BIND) ;
+
−}
+
−
+
−
+
−static void proc_listen(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_RESULT result ;
+
−  TRACE_FUNCTION("proc_listen()") ;
+
−
+
−  if ((result = sock_listen(pcont->psocket)) != SOCK_RESULT_OK)
+
−  {
+
−    sock_trace_result(pcont, "sock_listen()", result) ;
+
−    proc_shutdown(pcont) ;
+
−    return;
+
−  }
+
−  proc_new_state(pcont, PS_W_LISTN) ;
+
−}
+
−
+
−
+
−static void proc_incoming(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_CONNECT_IND *conn_ind ;
+
−  PROC_CONTEXT_T *newp ;
+
−  T_SOCK_RESULT result ;
+
−  TRACE_FUNCTION("proc_incoming()") ;
+
−
+
−  conn_ind = (T_SOCK_CONNECT_IND *) pcont->last_evt ;
+
−
+
−  if ((newp = proc_new_tcpfork(pcont)) EQ NULL)
+
−  {
+
−      TRACE_EVENT_P1("%s: failed to fork server, close new socket",
+
−                    proc_string(pcont)) ;
+
−      sock_close(conn_ind->new_socket) ;
+
−      return ;
+
−  }
+
−
+
−  /* We cannot make two calls to proc_string() without one overwriting the
+
−   * other, so we print the process strings in two successive traces. */
+
−  TRACE_EVENT_P1("%s: forking to handle client connection...",
+
−                 proc_string(pcont)) ;
+
−  TRACE_EVENT_P1("...forked process is %s", proc_string(newp)) ;
+
−  newp->psocket = conn_ind->new_socket ;
+
−  sock_set_callback(newp->psocket, app_sock_callback, newp) ;
+
−  TRACE_EVENT_P3("%s connection from %s:%d, looking up...", proc_string(pcont),
+
−                 inet_ntoa(conn_ind->peer_ipaddr), NTOHS(conn_ind->peer_port)) ;
+
−  if ((result = sock_gethostbyaddr(sock_api_inst, conn_ind->peer_ipaddr,
+
−                                   app_sock_callback, newp))
+
−      != SOCK_RESULT_OK)
+
−  {
+
−    sock_trace_result(newp, "sock_gethostbyaddr()", result) ;
+
−    proc_shutdown(newp) ;
+
−    proc_shutdown(pcont) ;
+
−    return;
+
−  }
+
−  proc_new_state(newp, PS_W_DNS) ;
+
−}
+
−
+
−
+
−static void proc_hostinfo_recvd(PROC_CONTEXT_T *pcont)
+
−{
+
−  T_SOCK_HOSTINFO_CNF *hinfo ;
+
−  TRACE_FUNCTION("proc_hostinfo_recvd()") ;
+
−
+
−  hinfo = (T_SOCK_HOSTINFO_CNF *) pcont->last_evt ;
+
−  if (hinfo->result != SOCK_RESULT_OK)
+
−  {
+
−    sock_trace_result(pcont, "SOCK_HOSTINFO_CNF", hinfo->result) ;
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT_P3("%s: connected peer is %s (%s)", proc_string(pcont),
+
−                   hinfo->hostname, inet_ntoa(hinfo->ipaddr)) ;
+
−  }
+
−  proc_begin_comm(pcont) ;
+
−}
+
−
+
−
+
−
+
−/*==== Exported functions ====================================================*/
+
−
+
−
+
−/** Initialize the application core.
+
− *
+
− * @param handle    own communication handle
+
− * @return PEI_OK/PEI_ERROR depending on the success of the initialization.
+
− */
+
−BOOL app_initialize_tcpip(T_HANDLE app_handle)
+
−{
+
−  TRACE_FUNCTION("app_initialize_tcpip()") ;
+
−  memset(&proc_context, 0, sizeof(proc_context)) ;
+
−  return PEI_OK ;
+
−}
+
−
+
−
+
−/* Macro for checking the Socket API events in app_sock_callback(). */
+
−#define CHECK_SOCK_EVT(evttype)                                       \
+
−{                                                                     \
+
−  if (event->event_type != evttype)                                   \
+
−  {                                                                   \
+
−    TRACE_ERROR("unexpected event type waiting for " #evttype) ;      \
+
−    proc_shutdown(pcont) ;                                            \
+
−    break ;                                                           \
+
−  }                                                                   \
+
−  if (event->result != SOCK_RESULT_OK)                                \
+
−  {                                                                   \
+
−    if(pcont->pstate == PS_W_DCM_OPEN OR                              \
+
−       pcont->pstate == PS_W_DCM_OPEN_ONLY)                           \
+
−       { proc_new_state(pcont, PS_IDLE); }                            \
+
−    proc_shutdown(pcont) ;                                            \
+
−    break ;                                                           \
+
−  }                                                                   \
+
−}
+
−
+
−
+
−/** Socket callback function as specified in the Socket API.
+
− *
+
− * @param event      Pointer to event struct passed by API.
+
− * @param context    Pointer to application context (here: process context)
+
− * @return
+
− */
+
−void app_sock_callback(T_SOCK_EVENTSTRUCT *event, void *context)
+
−{
+
−  PROC_CONTEXT_T *pcont ;
+
−  T_SOCK_BEARER_INFO_CNF *info;
+
−
+
−  TRACE_FUNCTION("app_sock_callback()") ;
+
−
+
−  pcont = (PROC_CONTEXT_T *)context ;
+
−  pcont->last_evt = event ;     /* Save event in process context. */
+
−
+
−  sock_trace_result(pcont, sock_event_string(event->event_type),
+
−                    event->result) ;
+
−  if (event->result != SOCK_RESULT_OK)
+
−  {
+
−    pcont->errors++ ;
+
−    if(event->result == SOCK_RESULT_NETWORK_LOST)
+
−    {
+
−      pcont->network_is_open = FALSE;
+
−    }
+
−  }
+
−  switch (pcont->pstate)        /* Do a preliminary check of the event. */
+
−  {
+
−    case PS_W_DCM_OPEN:            /* Waiting for DCM to open connection. */
+
−      CHECK_SOCK_EVT(SOCK_OPEN_BEARER_CNF);
+
−      
+
−      // FST: can't be evaluated-> see makro CHECK_SOCK_EVT
+
−      if (event->result != SOCK_RESULT_OK AND 
+
−          event->result != SOCK_RESULT_BEARER_ACTIVE)
+
−      {
+
−        proc_shutdown(pcont) ;
+
−        return ;
+
−      }
+
−      if (pcont->network_is_open)
+
−      {
+
−        TRACE_ERROR("SOCK_OPEN_BEARER_CNF received but pcont->network_is_open") ;
+
−        proc_shutdown(pcont);
+
−        return ;
+
−      }
+
−      pcont->network_is_open = TRUE ;
+
−      proc_open_socket(pcont) ;
+
−      break;
+
−      
+
−    case PS_W_DCM_OPEN_ONLY:
+
−      CHECK_SOCK_EVT(SOCK_OPEN_BEARER_CNF);
+
−      pcont->network_is_open = TRUE ;
+
−      proc_new_state(pcont, PS_DCM_OPEN);
+
−      break;
+
−
+
−    case PS_W_DCLOS:            /* Waiting for DCM to close connection. */
+
−      CHECK_SOCK_EVT(SOCK_CLOSE_BEARER_CNF);
+
−
+
−      if (!pcont->network_is_open AND pcont->pstate != PS_IDLE)
+
−      {
+
−        TRACE_ERROR("DCM_CONN_CLOSED received but !pcont->network_is_open") ;
+
−        proc_shutdown(pcont) ;
+
−        return ;
+
−      }
+
−      proc_finish(pcont) ;
+
−      break;
+
−
+
−    case PS_W_CONN_INFO:
+
−      CHECK_SOCK_EVT(SOCK_BEARER_INFO_CNF);
+
−
+
−      info = (T_SOCK_BEARER_INFO_CNF *)event;
+
−      app_print_conn_info(info);
+
−
+
−      TRACE_EVENT("SOCK_BEARER_INFO_CNF received");
+
−      break;
+
−
+
−    case PS_W_CREAT:            /* Waiting for socket create confirmation. */
+
−      CHECK_SOCK_EVT(SOCK_CREATE_CNF) ;
+
−      pcont->psocket = event->socket ;
+
−      pcont->psocket_is_open = TRUE ;
+
−      if (pcont->ptype EQ AP_TCPSRV)
+
−      {
+
−        proc_bind_socket(pcont) ;
+
−      }
+
−      else if(pcont->ipproto == SOCK_IPPROTO_TCP)
+
−      {
+
−        proc_connect_socket(pcont) ;
+
−      }
+
−      else
+
−      {
+
−        // This is not possible in the moment because the RNET_API does not 
+
−        // provide a sendto() function. Therefore it is is only possible to sent
+
−        // via "connected" UDP sockets.
+
−        // TODO: if the next statement will be enabled the "proc_connect_socket()" has to be removed!!
+
−        // proc_begin_comm(pcont);
+
−        proc_connect_socket(pcont) ;
+
−      }
+
−      break ;
+
−
+
−    case PS_W_BIND:
+
−      CHECK_SOCK_EVT(SOCK_BIND_CNF) ;
+
−      proc_listen(pcont) ;
+
−      break ;
+
−
+
−    case PS_W_LISTN:
+
−      CHECK_SOCK_EVT(SOCK_LISTEN_CNF) ;
+
−      app_pstat() ;
+
−      proc_new_state(pcont, PS_LISTENS) ; /* Nothing more to do here. */
+
−      break ;
+
−
+
−    case PS_LISTENS:            /* SOCK_CONNECT_IND or SOCK_CLOSE_CNF */
+
−      if (event->event_type EQ SOCK_CONNECT_IND)
+
−      {
+
−        proc_incoming(pcont) ;
+
−      }
+
−      break ;
+
−
+
−    case PS_W_DNS:
+
−      /* After sending connect confirm to client, client will send data to server
+
−         and server is dnsquerying now , server will be shutdown ,here Unfortunately..
+
−         but we want to exchange data happily, so this code is added....  */
+
−      if((event->event_type == SOCK_RECV_IND) AND (pcont->ptype == AP_TCPFORK))
+
−         break;
+
−
+
−      CHECK_SOCK_EVT(SOCK_HOSTINFO_CNF) ;
+
−      proc_hostinfo_recvd(pcont) ;
+
−      break ;
+
−
+
−    case PS_W_SCONN:            /* Waiting for socket connect confirmation. */
+
−      CHECK_SOCK_EVT(SOCK_CONNECT_CNF) ;
+
−      proc_begin_comm(pcont) ;
+
−      break ;
+
−
+
−    case PS_COMM:               /* Happily exchanging data. */
+
−      comm_event(pcont) ;
+
−      break ;
+
−
+
−    case PS_W_SCLOS:            /* Waiting for socket close confirmation. */
+
−      CHECK_SOCK_EVT(SOCK_CLOSE_CNF) ;
+
−                                                                     
+
−      pcont->psocket_is_open = FALSE ;
+
−      pcont->psocket = 0;
+
−      app_pstat() ;
+
−      if (pcont->n_reps >= pcont->spec_reps OR
+
−          pcont->in_shutdown)
+
−      {        
+
−        proc_close_conn(pcont) ;
+
−      }
+
−      else
+
−      {
+
−        pcont->data_sent = 0 ;
+
−        pcont->data_rcvd = 0 ;
+
−        pcont->items_sent = 0 ;
+
−        pcont->items_rcvd = 0 ;
+
−        proc_open_socket(pcont) ;
+
−      }
+
−      break ;
+
−
+
−    case PS_IDLE:               /* Initial state, process not running. */
+
−      TRACE_EVENT_P2("app_sock_callback(): %s receives %s (ignored)",
+
−                     proc_string(pcont), sock_event_string(event->event_type)) ;
+
−      break ;
+
−
+
−    case PS_DCM_OPEN:
+
−      if(event->event_type == SOCK_BAERER_CLOSED_IND)
+
−      {
+
−        TRACE_ERROR("SOCK_BAERER_CLOSED_IND -> Shutdown");
+
−        if(event->result == SOCK_RESULT_NETWORK_LOST)
+
−        {
+
−          pcont->network_is_open = FALSE;
+
−        }
+
−        proc_shutdown(pcont) ;
+
−      }
+
−      break;
+
−    
+
−    case PS_INVALID:            /* Invalid state. */
+
−      TRACE_EVENT_P1("app_sock_callback(): %s invalid state", proc_string(pcont)) ;
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR("app_sock_callback(): Default Statement");
+
−      break;
+
−      /*
+
−      if(event->event_type == SOCK_DCM_ERR_IND)
+
−      {
+
−        TRACE_ERROR("SOCK_DCM_ERR_IND -> Shutdown");
+
−      }
+
−      proc_shutdown(pcont) ;
+
−      return ;
+
−      */
+
−  }
+
−  /* Free data buffer if it has not been freed yet. */
+
−  if ( (event->event_type EQ SOCK_RECV_IND) AND
+
−       ((T_SOCK_RECV_IND *) event)->data_buffer )
+
−  {
+
−    MFREE(((T_SOCK_RECV_IND *) event)->data_buffer) ;
+
−  }
+
−  pcont->last_evt = NULL ;
+
−  TRACE_EVENT_P1("leave app_sock_callback() for %s", proc_string(pcont)) ;
+
−}
+
−
+
−
+
−
+
−/*
+
− * Application command functions.
+
− */
+
−
+
−
+
−/** Start a data communication process of the appropriate type..
+
− *
+
− * @param size     Amount of data to download or number of items to transfer.
+
− */
+
−void app_start_tcpdl(int prov, int size, int reps)
+
−{ proc_init(prov, size, reps, AP_TCPDL, SOCK_IPPROTO_TCP,
+
−            port_number ? port_number : PORT_CHARGEN) ; }
+
−
+
−void app_start_tcpul(int prov, int size, int reps)
+
−{ proc_init(prov, size, reps, AP_TCPUL, SOCK_IPPROTO_TCP,
+
−            port_number ? port_number : PORT_DISCARD) ; }
+
−
+
−void app_start_udpdl(int prov, int size, int reps)
+
−{ proc_init(prov, size, reps, AP_UDPDL, SOCK_IPPROTO_UDP,
+
−            port_number ? port_number : PORT_CHARGEN) ; }
+
−
+
−void app_start_udpul(int prov, int size, int reps)
+
−{ proc_init(prov, size, reps, AP_UDPUL, SOCK_IPPROTO_UDP,
+
−            port_number ? port_number : PORT_DISCARD) ; }
+
−
+
−void app_start_tcpecho(int prov, int items, int reps)
+
−{ proc_init(prov, items, reps, AP_TCPECHO, SOCK_IPPROTO_TCP,
+
−            port_number ? port_number : PORT_ECHO) ; }
+
−
+
−void app_start_udpecho(int prov, int items, int reps)
+
−{ proc_init(prov, items, reps, AP_UDPECHO, SOCK_IPPROTO_UDP,
+
−            port_number ? port_number : PORT_ECHO) ; }
+
−
+
−void app_start_dnsquery(int prov, int times, char *address)
+
−{
+
−  if (address)
+
−  {
+
−    strncpy(query_name, address, FQDN_LENGTH) ;
+
−  }
+
−  else
+
−  {
+
−    query_name[0] =0 ;
+
−  }
+
−  proc_init(prov, times,1, AP_DNSQRY,(T_SOCK_IPPROTO)0, 0) ;
+
−}
+
−
+
−void app_start_tcpsrv(int prov, int port, int repeat)
+
−{ proc_init(prov, 0, repeat, AP_TCPSRV, SOCK_IPPROTO_TCP, port) ; }
+
−
+
−
+
−
+
−/** Shutdown the specified process.
+
− *
+
− * @param pid    Process ID.
+
− */
+
−void app_shutdown(void)
+
−{
+
−  TRACE_FUNCTION("app_shutdown()") ;
+
−  proc_shutdown(&proc_context) ;
+
−}
+
−
+
−
+
−/** Set the current server name or IP address.
+
− *
+
− * @param server    Name or IP address (in dotted decimal notation) of server.
+
− */
+
−void app_server(char *server)
+
−{
+
−  if (server)
+
−  {
+
−    strncpy(server_name, server, FQDN_LENGTH) ;
+
−  }
+
−  TRACE_EVENT_P1("server_name is %s", server_name) ;
+
−}
+
−
+
−
+
−/** Set or show the current buffer size.
+
− *
+
− * @param bufsize    size of buffer as a string or NULL
+
− */
+
−void app_buffer(char *bufsize)
+
−{
+
−  if (bufsize)
+
−  {
+
−    buffer_size = atoi(bufsize) ;
+
−  }
+
−  TRACE_EVENT_P1("buffer_size is %d", buffer_size) ;
+
−}
+
−
+
−
+
−/** Set or show the current buffer size.
+
− *
+
− * @param port     port number override
+
− */
+
−void app_port(char *port)
+
−{
+
−  if (port)
+
−  {
+
−    port_number = (U16) atoi(port) ;
+
−  }
+
−  if (port_number)
+
−  {
+
−    TRACE_EVENT_P1("port number override is %d", port_number) ;
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT("standard port numbers used") ;
+
−  }
+
−}
+
−
+
−
+
−/** Set or show the current bearer type.
+
− *
+
− * @param bearer     bearer type
+
− */
+
−void app_bearer(char *bearer)
+
−{
+
−  if (bearer)
+
−  {
+
−    if (!strcmp(string_to_lower(bearer), "any"))
+
−    {
+
−      sock_bearer_type = SOCK_BEARER_ANY;
+
−    }
+
−    else if (!strcmp(string_to_lower(bearer), "gprs"))
+
−    {
+
−      sock_bearer_type = SOCK_BEARER_GPRS ;
+
−    }
+
−    else if (!strcmp(string_to_lower(bearer), "gsm"))
+
−    {
+
−      sock_bearer_type = SOCK_BEARER_GSM;
+
−    }
+
−    else if (!strcmp(string_to_lower(bearer), "prof"))
+
−    {
+
−      sock_bearer_type = SOCK_BEARER_USE_PROFILE;
+
−    }    
+
−    else if (!strcmp(string_to_lower(bearer), "spec"))
+
−    {
+
−      sock_bearer_type = SOCK_BEARER_AS_SPECIFIED;
+
−    }
+
−
+
−    else
+
−    {
+
−      TRACE_EVENT_P1("bearer type %s unknown", bearer) ;
+
−    }
+
−  }
+
−  TRACE_EVENT_P1("bearer type is %s", sock_bearer_type_string(sock_bearer_type)) ;
+
−}
+
−
+
−
+
−/** Trace information about the process.
+
− */
+
−void app_pstat(void)
+
−{
+
−  PROC_CONTEXT_T *pcont ;
+
−
+
−  TRACE_FUNCTION("app_pstat()") ;
+
−
+
−  pcont = &proc_context ;
+
−  TRACE_EVENT_P3("%s in_shutdown %d last_evt %08x",
+
−                 proc_string(pcont), pcont->in_shutdown, pcont->last_evt) ;
+
−  TRACE_EVENT_P6("prot %d srv %s %s:%d sp_it %d sp_rep %d",
+
−                 pcont->ipproto,
+
−                 pcont->server_name ? pcont->server_name : "",
+
−                 inet_ntoa(pcont->server_ipaddr),
+
−                 NTOHS(pcont->server_port),
+
−                 pcont->spec_items,
+
−                 pcont->spec_reps) ;
+
−  TRACE_EVENT_P6("dta tx %d dta rx %d it tx %d it rx %d rep %d errs %d",
+
−                 pcont->data_sent,
+
−                 pcont->data_rcvd,
+
−                 pcont->items_sent,
+
−                 pcont->items_rcvd,
+
−                 pcont->n_reps,
+
−                 pcont->errors) ;
+
−  TRACE_EVENT_P5("Socket descr: %x, %sNetwork%s, %spSocket%s",
+
−                 pcont->psocket,
+
−                 pcont->network_is_open ? "" : "no ",
+
−                 pcont->network_is_open ? " open" : "",
+
−                 pcont->psocket_is_open ? "" : "no ",
+
−                 pcont->psocket_is_open ? " open" : "") ;
+
−  TRACE_EVENT_P4("global: server %s query %s buffer %d port %d",
+
−                 server_name, query_name, buffer_size, port_number) ;
+
−}
+
−
+
−
+
−/** Make the application stop or continue receiving data from the network by
+
− * calling the xoff or xon function, respectively.
+
− *
+
− * @param flow_on    if non-zero, switch flow on; off otherwise.
+
− */
+
−void app_switch_flow(int flow_on)
+
−{
+
−  PROC_CONTEXT_T *pcont = &proc_context ;
+
−  TRACE_FUNCTION("app_switch_flow()") ;
+
−
+
−  if (flow_on)
+
−  {
+
−    TRACE_EVENT("switching socket to xon") ;
+
−    sock_flow_xon(pcont->psocket) ;
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT("switching socket to xoff") ;
+
−    sock_flow_xoff(pcont->psocket) ;
+
−  }
+
−}
+
−
+
−
+
−LOCAL void app_print_conn_info(T_SOCK_BEARER_INFO_CNF *info)
+
−{
+
−  TRACE_EVENT_P1("BearerType: %s",
+
−                 sock_bearer_type_string(info->bearer_params.bearer_type));
+
−  TRACE_EVENT_P1("APN: %s", info->bearer_params.apn);
+
−  TRACE_EVENT_P1("PhoneNumber: %s", info->bearer_params.phone_nr);
+
−  TRACE_EVENT_P1("UserId: %s", info->bearer_params.user_id);
+
−  TRACE_EVENT_P1("Password: %s", info->bearer_params.password);
+
−  TRACE_EVENT_P1("IP-Address: %s", inet_ntoa(info->bearer_params.ip_address));
+
−  TRACE_EVENT_P1("DNS1-Address: %s", inet_ntoa(info->bearer_params.dns1));  
+
−  TRACE_EVENT_P1("DNS2-Address: %s", inet_ntoa(info->bearer_params.dns2));
+
−  TRACE_EVENT_P1("Gateway-Address: %s", inet_ntoa(info->bearer_params.gateway));
+
−  TRACE_EVENT_P1("CID: %d",info->bearer_params.cid);
+
−}
+
−
+
−
+
−
+
−void app_open_bearer(int prov, int size, int reps)
+
−{
+
−  proc_context.bearer_only = TRUE;
+
−  proc_init(prov, size, reps, AP_NONE, SOCK_IPPROTO_TCP, port_number );
+
−  proc_context.bearer_only = FALSE;
+
−  
+
−}
+
−
+
−void app_close_bearer()
+
−{
+
−  app_shutdown();
+
−}
+
−
+
−
+
−#endif /* FF_GPF_TCPIP */
+
−
+
−/* EOF */