tcp_client.h

Go to the documentation of this file.

 
#ifndef __TCP_CLIENT_H__
#define __TCP_CLIENT_H__
 
#include "web_radio_config.h"
#include <iostream>
#include <iomanip>
#include "stations.h"
#include "ntpudp.h"
#include <mp3dec.h>
#include "mp3common.h"
#include "mp3player.h"
 
enum client_states {
    ES_NOT_CONNECTED = 0,
    ES_CONNECTED,
    ES_RECEIVED,
    ES_CLOSING,
};
 
struct client {
    enum client_states state; 
    struct tcp_pcb *pcb;      
    struct pbuf *p_tx;        
};
 
extern uint8_t file_read_buffer[FILE_READ_BUFFER_SIZE];
 
/* Exported variables --------------------------------------------------------*/
extern char stationname[160];
extern char metaint[10];
extern volatile int metnum; 
extern volatile uint8_t data_with_metainfo[12000]; 
extern volatile uint8_t metainfo_present;
 
static long long int totaldatacount;
static long long int lencounter;
extern char *payloadtemp;
 
extern int metainterval; 
extern char *strptr;
extern char *startnameptr;
extern char *ptr2;
extern char httpstr[160];
 
extern volatile uint64_t message_count;
extern long long unsigned int sent_len;
extern char initial_pipe[20000];
extern char meta_string[15 * 256];
extern volatile int insertion_point;
extern volatile int insertion_point_maximum;
extern volatile int inserted_len;
extern volatile int curr_len;
extern volatile int msg_len_max;
extern volatile int meta_start_index;
extern volatile int meta_info_len;
 
extern volatile int items;
 
extern DNS_desc_t Server[MaxStation];
 
class TcpClient
{
  public:
    Mp3Player *m_mp3;
    Station *stations = Stationlist;
    DNS_desc_t *server = Server;
    struct netif *gnetif;
 
    TcpClient(Mp3Player *mp3, struct netif *connection)
    {
        this->m_mp3 = mp3;
        this->gnetif = connection;
    };
    struct client *es = (struct client *)mem_malloc(sizeof(struct client));
 
    void connect(ip_addr_t DestIPaddr, uint16_t DEST_PORT);
 
    void disconnect(void);
 
    void connectionClose(struct tcp_pcb *tpcb, struct client *es);
 
    void process(void);
 
    void analysisOfMetaInfo(void);
 
    void updateStation(void);
 
    void gateActivities(void);
 
    void adjustBuffer();
 
  private:
    static err_t connected(void *arg, struct tcp_pcb *tpcb, err_t err)
    {
        TcpClient *es = (TcpClient *)arg;
 
        std::cout << "CONNECTED = " << (int)err << std::endl;
 
        if (err == ERR_OK) {
            if (es != NULL) {
                // printf ("ES <> 0 \n\r");
                es->es->state = ES_CONNECTED;
                es->es->pcb = tpcb;
 
                /* allocate pbuf */
                es->es->p_tx = pbuf_alloc(PBUF_TRANSPORT,
                                          strlen((char *)httpstr), PBUF_POOL);
                // printf ("pbuf allocated \n\r");
 
                if (es->es->p_tx) {
                    // printf (" es->p_tx \n\r");
 
                    /* copy data to pbuf */
                    pbuf_take(es->es->p_tx, (char *)httpstr,
                              strlen((char *)httpstr));
 
                    // printf (" pbuf_take \n\r");
 
                    /* pass newly allocated es structure as argument to tpcb */
                    // tcp_arg(tpcb, es);
 
                    // printf (" tpcb_arg \n\r");
 
                    /* initialize LwIP tcp_recv callback function */
                    tcp_recv(tpcb, es->recv);
 
                    // printf (" tcp_recv \n\r");
 
                    /* initialize LwIP tcp_sent callback function */
                    tcp_sent(tpcb, es->sent);
 
                    // printf (" tcp_sent \n\r");
 
                    /* initialize LwIP tcp_poll callback function */
                    tcp_poll(tpcb, es->poll, 1);
 
                    // printf (" tcp_poll \n\r");
 
                    /* send data */
                    es->send(tpcb, es->es);
                    // printf ("HHTP REQUEST DATA SENT: %s \n\r", httpstr);
 
                    return ERR_OK;
                }
            } else {
                /* close connection */
                es->connectionClose(tpcb, es->es);
 
                std::cout << " connectionClose top \n\r";
 
                /* return memory allocation error */
                return ERR_MEM;
            }
        } else {
            /* close connection */
            es->connectionClose(tpcb, es->es);
            std::cout << " connectionClose bottom\n\r";
        }
        return err;
    }
 
    static err_t recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
                      err_t err)
    {
        err_t ret_err = 0;
 
        LWIP_ASSERT("arg != NULL", arg != NULL);
 
        TcpClient *es = (TcpClient *)arg;
 
        /* if we receive an empty tcp frame from server => close connection */
        if (p == NULL) {
            std::cout << " remote host closed \n\r";
 
            /* remote host closed connection */
            es->es->state = ES_CLOSING;
            if (es->es->p_tx == NULL) {
                /* we're done sending, close connection */
                es->connectionClose(tpcb, es->es);
                std::cout << " done closing \n\r";
 
            } else {
                /* send remaining data*/
                es->send(tpcb, es->es);
                // printf (" send remaining \n\r");
            }
            ret_err = ERR_OK;
        }
        /* else : a non empty frame was received from  server but for some
           reason err != ERR_OK */
        else if (err != ERR_OK) {
            /* free received pbuf*/
            if (p != NULL) {
                pbuf_free(p);
                // printf (" pbuf free \n\r");
            }
            ret_err = err;
        } else if ((es->es->state == ES_CONNECTED) &
                   (items <
                    TCPBUFF_MAXITEMS)) //  & (items < 80000) can be ommitted
                                       //  if RAM size >> 3 MBytes
        {
            /* ***************** Successful reception of  message
             * ********************/
            /* *************  WebRadio Message processing starts here
             * ****************/
            /* ***********************************************************************/
 
            message_count++;
            sent_len += p->tot_len;
 
            if (msg_len_max < (p->tot_len)) // only for display
            {
                msg_len_max = p->tot_len;
            }
 
            // special case for Linux shoutcast server 1.9.7 or 1.9.8:
            // discard first package (typically 171 bytes long)
            if (sent_len < 200) // for sure: message 1
            {
                message_count = 0;
                sent_len = 0;
            }
 
            // extract metainfo from first answer message
            if (message_count == 1) {
                pbuf_copy_partial(p, initial_pipe, p->tot_len, 0);
                payloadtemp = initial_pipe;
 
                // Extract station name
                const char needle[] = "icy-name:";
                strptr = strstr(initial_pipe, needle);
                stationname[0] = 0;
 
                if (strptr != NULL) {
                    startnameptr = strptr + 9;
                    for (ptr2 = startnameptr; (ptr2 - startnameptr) < 160;
                         ptr2++) // 160 length stationname array
                    {
                        if (*ptr2 == '\r') {
                            break;
                        }
                        strncat((char *)stationname, ptr2, 1);
                    }
                    stationname[ptr2 - startnameptr] = 0;
                    // printf ("ICY STATION NAME FOUND: >%s<\n\r", stationname);
                }
 
                // Extract metainfo interval length
                const char needle2[] = "icy-metaint:";
                metnum = 0;
                metaint[0] = 0;
                strptr = strstr(initial_pipe, needle2);
                if (strptr != NULL) {
                    startnameptr = strptr + 12;
                    for (ptr2 = startnameptr; (ptr2 - startnameptr) < 10;
                         ptr2++) // assume metainterval < 999999999
                    {
                        if (*ptr2 == '\r') {
                            break;
                        }
                        strncat((char *)metaint, ptr2, 1);
                    }
                    metaint[ptr2 - startnameptr] = 0; // letztes Byte ist Ende
                    // printf ("ICY METAINT INTERVAL LENGTH FOUND: >%s<END\n\r",
                    // metaint);
                    metnum = atoi(metaint);
                    // printf ("Numerical Value metaint: %d\n\r", metnum);
                }
 
                // parse end of metainfo
                for (int ii = 0; ii < (int)sent_len; ii++) {
                    strncat((char *)data_with_metainfo, payloadtemp, 1);
                    payloadtemp++;
 
                    if ((*payloadtemp == '\r') & (*(payloadtemp + 1) == '\n') &
                        (*(payloadtemp + 2) == '\r') &
                        (*(payloadtemp + 3) == '\n')) {
                        strncat((char *)data_with_metainfo, payloadtemp, 4);
                        totaldatacount =
                            ii +
                            5; // +  first byte after CRLFCRLF == first MP3 byte
                        break;
                    }
                }
 
                // *** Store the first bytes of the MP3 Data (are always already
                // in message 1!)
                // *** in TCPBuffer
                lencounter = sent_len - totaldatacount;
                es->m_mp3->insertTcpBuffer(
                    (uint8_t *)(initial_pipe + totaldatacount), lencounter);
                insertion_point = 0;
                inserted_len = inserted_len + lencounter; //
 
                metainterval = -1;
                if (metnum) {
                    metainterval = metnum;
                }
 
            } // end message 1 processing
 
            if (message_count > 1) {
                //     printf ("1: enter len %05d \n\r", p->tot_len);
 
                curr_len = p->tot_len;
                pbuf_copy_partial(p, initial_pipe + insertion_point, p->tot_len,
                                  0);
 
                //     MP3Buf_insert (initial_pipe, p->tot_len); // could be
                //     last before one
 
                //     printf ("1: ip:%05d ", insertion_point);
 
                insertion_point += curr_len;
                lencounter += curr_len;
 
                //     printf ("2:  ip:%05d cl:%05d ", insertion_point,
                //     curr_len);
 
                // Check for metainfo if more than 10000 Bytes in pipe and cut
                // it out if start of metainfo is lower than index 5000 note
                // maximum message length is 5840 bytes
 
                if (insertion_point > 12000) {
                    if (insertion_point_maximum < insertion_point) {
                        insertion_point_maximum = insertion_point;
                    }
 
                    //      printf ("3: ip:%05d ", insertion_point);
                    es->m_mp3->insertTcpBuffer(
                        (uint8_t *)initial_pipe,
                        curr_len); // could be last before one length, but will
                                   // average out anyway over message lengths
                    memmove(initial_pipe, initial_pipe + curr_len,
                            insertion_point -
                                curr_len); // shift content of initial
                                           // pipe left by p->tot_len
                    insertion_point = insertion_point - curr_len;
 
                    // -----------------------------------------------------------------------------------
                    inserted_len = inserted_len + curr_len;
                    if (metnum) {
                        meta_start_index = (metnum - inserted_len);
                        //       printf (" %03d ", meta_start_index);
 
                        //      printf ("m: %05d \n\r", meta_start_index);
 
                        if (meta_start_index <
                            6000) // if startmetainfo is roughly in lower
                                  // quarter of initial_pipe, 5840 is max msg
                                  // size!!
                        {
                            es->m_mp3->insertTcpBuffer(
                                (uint8_t *)initial_pipe,
                                meta_start_index); // move MP3 data (before
                                                   // metainfo starts) to
                                                   // MP3Buffer
 
                            memmove(
                                initial_pipe, initial_pipe + meta_start_index,
                                insertion_point -
                                    meta_start_index); // shift start  of
                                                       // metainfo to beginning
                                                       // of intitial_pipe
                            insertion_point =
                                insertion_point - meta_start_index;
 
                            meta_info_len =
                                (*(uint8_t *)(initial_pipe)*16) +
                                1; // length of following metainfo now
                                   // at element 0 of initial_pipe
 
                            //           printf ("\n\r --- %03d --- %03d
                            //----\n\r", meta_info_len, MP3errorcount);
 
                            if (meta_info_len > 1) {
                                meta_string[0] = 0;
                                strncpy(meta_string, initial_pipe + 1,
                                        meta_info_len);
                                meta_string[meta_info_len] = 0;
                                //           printf ("string: %s \n\r",
                                // meta_string);
                                metainfo_present = 1;
                            }
 
                            memmove(initial_pipe, initial_pipe + meta_info_len,
                                    insertion_point -
                                        meta_info_len); // shift metainfo out of
                                                        // stream
                            insertion_point = insertion_point - meta_info_len;
                            inserted_len = 0;
                        }
                    }
                }
            }
            /* *************  WebRadio Message processing ends here ***********
             */
            /* ****************************************************************
             */
 
            /* Acknowledge data reception */
            tcp_recved(tpcb, p->tot_len);
            //    //printf ("*");
 
            /* free pbuf and do nothing */
            pbuf_free(p);
            //    //printf ("_");
            ret_err = ERR_OK;
        }
 
        /* data received when connection already closed */
        else if (items < TCPBUFF_MAXITEMS) {
            /* Acknowledge data reception */
            tcp_recved(tpcb, p->tot_len);
            // printf ("ack_\n\r");
            /* free pbuf and do nothing */
            pbuf_free(p);
 
            // printf ("freed_\n\r");
            ret_err = ERR_OK;
        }
        return ret_err;
    }
 
    static void send(struct tcp_pcb *tpcb, struct client *es)
    {
        struct pbuf *ptr;
        err_t wr_err = ERR_OK;
 
        while ((wr_err == ERR_OK) && (es->p_tx != NULL) &&
               (es->p_tx->len <= tcp_sndbuf(tpcb))) {
            /* get pointer on pbuf from es structure */
            ptr = es->p_tx;
 
            /* enqueue data for transmission */
            wr_err = tcp_write(tpcb, ptr->payload, ptr->len, 1);
 
            tcp_output(tpcb); // to make it send the data immediately
 
 
            if (wr_err == ERR_OK) {
                /* continue with next pbuf in chain (if any) */
                es->p_tx = ptr->next;
 
                if (es->p_tx != NULL) {
                    /* increment reference count for es->p */
                    pbuf_ref(es->p_tx);
                }
 
                /* free pbuf: will free pbufs up to es->p (because es->p has a
                 * reference count > 0) */
                pbuf_free(ptr);
            } else if (wr_err == ERR_MEM) {
                /* we are low on memory, try later, defer to poll */
                es->p_tx = ptr;
            } else {
                /* other problem ?? */
            }
        }
    }
 
    static err_t poll(void *arg, struct tcp_pcb *tpcb)
    {
        err_t ret_err;
        TcpClient *es = (TcpClient *)arg;
        if (es->es != NULL) {
            if (es->es->p_tx != NULL) {
                /* there is a remaining pbuf (chain) , try to send data */
                es->send(tpcb, es->es);
            } else {
                /* no remaining pbuf (chain)  */
                if (es->es->state == ES_CLOSING) {
                    /* close tcp connection */
                    es->connectionClose(tpcb, es->es);
                }
            }
            ret_err = ERR_OK;
        } else {
            /* nothing to be done */
            tcp_abort(tpcb);
            ret_err = ERR_ABRT;
        }
        return ret_err;
    }
 
    static err_t sent(void *arg, struct tcp_pcb *tpcb, u16_t len)
    {
        LWIP_UNUSED_ARG(len);
        TcpClient *es = (TcpClient *)arg;
 
        if (es->es->p_tx != NULL) {
            /* still got pbufs to send */
            es->send(tpcb, es->es);
        }
 
        return ERR_OK;
    }
    void clearAudioBuffer(void)
    {
        for (int i = 0; i < AUDIO_BUFFER_SIZE; i++) {
            BufferCtl.buff[i] = 0;
        }
    }
    void clearFileReadBuffer(void)
    {
        for (int i = 0; i < FILE_READ_BUFFER_SIZE; i++) {
            file_read_buffer[i] = 0;
        }
    }
};
 
#endif /* __TCP_CLIENT_H__ */