sap.c

uclinux 下的vlc播放器源代码

            if (p_sdp->i_in == 4)
            {
                /* Skip IPv4-specific TTL indication */
                psz_eof = strchr (psz_parse, '/');
            }

            if ((psz_eof != NULL) && (atoi (psz_eof + 1) != 1))
            {
                msg_Warn (p_obj, "unsupported layered stream (%s layers)",
                          psz_eof + 1);
                return VLC_EGENERIC;
            }
	}

        if( strchr( psz_parse, ':' ) != NULL )
        {
            if( asprintf( &psz_uri, "[%s]", psz_parse ) == -1 )
                psz_uri = NULL;
        }
        else psz_uri = strdup( psz_parse );

    }

    /* Parse m= field */
    if( p_sdp->psz_media )
    {
        psz_parse = p_sdp->psz_media;

        psz_eof = strchr( psz_parse, ' ' );

        if( psz_eof )
        {
            *psz_eof = '\0';

            if( strncmp( psz_parse, "audio", 5 )  &&
                strncmp( psz_parse, "video", 5 ) )
            {
                msg_Warn( p_obj, "unhandled media type -%s-", psz_parse );
                FREE( psz_uri );
                return VLC_EGENERIC;
            }

            psz_parse = psz_eof + 1;
        }
        else
        {
            msg_Warn( p_obj, "unable to parse m field (1)");
            FREE( psz_uri );
            return VLC_EGENERIC;
        }

        psz_eof = strchr( psz_parse, ' ' );

        if( psz_eof )
        {
            *psz_eof = '\0';

            /* FIXME : multiple port ! */
            i_port = atoi( psz_parse );

            if( i_port <= 0 || i_port >= 65536 )
            {
                msg_Warn( p_obj, "invalid transport port %i", i_port );
            }

            psz_parse = psz_eof + 1;
        }
        else
        {
            msg_Warn( p_obj, "unable to parse m field (2)");
            FREE( psz_uri );
            return VLC_EGENERIC;
        }

        psz_eof = strchr( psz_parse, ' ' );

        if( psz_eof )
        {
            *psz_eof = '\0';
            psz_proto = strdup( psz_parse );

            psz_parse = psz_eof + 1;
            p_sdp->i_media_type = atoi( psz_parse );

        }
        else
        {
            msg_Dbg( p_obj, "incorrect m field, %s", p_sdp->psz_media );
            p_sdp->i_media_type = 33;
            psz_proto = strdup( psz_parse );
        }
    }

    if( psz_proto && !strncmp( psz_proto, "RTP/AVP", 7 ) )
    {
        free( psz_proto );
        psz_proto = strdup( "rtp" );
    }
    if( psz_proto && !strncasecmp( psz_proto, "UDP", 3 ) )
    {
        free( psz_proto );
        psz_proto = strdup( "udp" );
    }

    /* FIXME: HTTP support */

    if( i_port == 0 )
    {
        i_port = 1234;
    }

    /* handle SSM case */
    psz_parse = GetAttribute( p_sdp, "source-filter" );
    if (psz_parse != NULL)
    {
        char psz_source_ip[256];

        if (sscanf (psz_parse, " incl IN IP%*c %*s %255s ", psz_source_ip) == 1)
        {
            if (strchr (psz_source_ip, ':') != NULL)
                sprintf (psz_source, "[%s]", psz_source_ip);
            else
                strcpy (psz_source, psz_source_ip);
        }
    }

    asprintf( &p_sdp->psz_uri, "%s://%s@%s:%i", psz_proto, psz_source,
              psz_uri, i_port );

    FREE( psz_uri );
    FREE( psz_proto );
    return VLC_SUCCESS;
}

/***********************************************************************
 * ParseSDP : SDP parsing
 * *********************************************************************
 * Validate SDP and parse all fields
 ***********************************************************************/
static sdp_t *  ParseSDP( vlc_object_t *p_obj, char* psz_sdp )
{
    sdp_t *p_sdp;
    vlc_bool_t b_invalid = VLC_FALSE;
    vlc_bool_t b_end = VLC_FALSE;
    if( psz_sdp == NULL )
    {
        return NULL;
    }

    if( psz_sdp[0] != 'v' || psz_sdp[1] != '=' )
    {
        msg_Warn( p_obj, "bad packet" );
        return NULL;
    }

    p_sdp = (sdp_t *)malloc( sizeof( sdp_t ) );
    if( p_sdp == NULL )
        return NULL;

    /* init to 0 */
    memset( p_sdp, 0, sizeof( sdp_t ) );

    p_sdp->psz_sdp = strdup( psz_sdp );
    if( p_sdp->psz_sdp == NULL )
    {
        free( p_sdp );
        return NULL;
    }

    while( *psz_sdp != '\0' && b_end == VLC_FALSE  )
    {
        char *psz_eol = NULL;
        char *psz_eof = NULL;
        char *psz_parse = NULL;
        char *psz_sess_id = NULL;

        while( *psz_sdp == '\r' || *psz_sdp == '\n' ||
               *psz_sdp == ' ' || *psz_sdp == '\t' )
        {
            psz_sdp++;
        }

        if( ( psz_eol = strchr( psz_sdp, '\n' ) ) == NULL )
        {
            psz_eol = psz_sdp + strlen( psz_sdp );
            b_end = VLC_TRUE;
        }
        if( psz_eol > psz_sdp && *( psz_eol - 1 ) == '\r' )
        {
            psz_eol--;
        }

        if( psz_eol <= psz_sdp )
        {
            break;
        }
        *psz_eol++ = '\0';

        /* no space allowed between fields */
        if( psz_sdp[1] != '=' )
        {
            msg_Warn( p_obj, "invalid packet" ) ;
            FreeSDP( p_sdp ); p_sdp = NULL;
            return NULL;
        }

        /* Now parse each line */
        switch( psz_sdp[0] )
        {
            case( 'v' ):
                break;
            case( 's' ):
                p_sdp->psz_sessionname = strdup( &psz_sdp[2] );
                break;
            case ( 'o' ):
            {
                int i_field = 0;
                /* o field is <username> <session id> <version>
                 *  <network type> <address type> <address> */

#define GET_FIELD( store ) \
                psz_eof = strchr( psz_parse, ' ' ); \
                if( psz_eof ) \
                { \
                    *psz_eof=0; store = strdup( psz_parse ); \
                } \
                else \
                { \
                    if( i_field != 5 ) \
                    { \
                        b_invalid = VLC_TRUE; break; \
                    } \
                    else \
                    { \
                        store = strdup( psz_parse ); \
                    } \
                }; \
                psz_parse = psz_eof + 1; i_field++;


                psz_parse = &psz_sdp[2];
                GET_FIELD( p_sdp->psz_username );
                GET_FIELD( psz_sess_id );

                p_sdp->i_session_id = atoll( psz_sess_id );

                FREE( psz_sess_id );

                GET_FIELD( psz_sess_id );
                FREE( psz_sess_id );

                GET_FIELD( p_sdp->psz_network_type );
                GET_FIELD( p_sdp->psz_address_type );
                GET_FIELD( p_sdp->psz_address );

                break;
            }
            case( 'i' ):
            case( 'u' ):
            case( 'e' ):
            case( 'p' ):
            case( 't' ):
            case( 'r' ):
                break;
            case( 'a' ): /* attribute */
            {
                char *psz_eon = strchr( &psz_sdp[2], ':' );
                attribute_t *p_attr = malloc( sizeof( attribute_t ) );

                /* Attribute with value */
                if( psz_eon )
                {
                    *psz_eon++ = '\0';

                    p_attr->psz_field = strdup( &psz_sdp[2] );
                    p_attr->psz_value = strdup( psz_eon );
                }
                else /* Attribute without value */
                {
                    p_attr->psz_field = strdup( &psz_sdp[2] );
                    p_attr->psz_value = NULL;
                }

                TAB_APPEND( p_sdp->i_attributes, p_sdp->pp_attributes, p_attr );
                break;
            }

            case( 'm' ): /* Media announcement */
            {
                /* If we have several medias, we pass the announcement to
                 * LIVE.COM, so just count them */
                p_sdp->i_media++;
                if( p_sdp->i_media == 1 )
                {
                    p_sdp->psz_media = strdup( &psz_sdp[2] );
                }
                break;
            }

            case( 'c' ):
            {
                if( p_sdp->psz_connection != NULL ) // FIXME
                    break;

                p_sdp->psz_connection = strdup( &psz_sdp[2] );
                break;
            }

            default:
               break;
        }

        if( b_invalid )
        {
            FreeSDP( p_sdp ); p_sdp = NULL;
            return NULL;
        }

        psz_sdp = psz_eol;
    }

    return p_sdp;
}

static int InitSocket( services_discovery_t *p_sd, const char *psz_address,
                       int i_port )
{
    int i_fd = net_OpenUDP( p_sd, psz_address, i_port, NULL, 0 );

    if( i_fd != -1 )
    {
        net_StopSend( i_fd );
        INSERT_ELEM(  p_sd->p_sys->pi_fd, p_sd->p_sys->i_fd,
                      p_sd->p_sys->i_fd, i_fd );
        return VLC_SUCCESS;
    }

    return VLC_EGENERIC;
}

#ifdef HAVE_ZLIB_H
static int Decompress( unsigned char *psz_src, unsigned char **_dst, int i_len )
{
    int i_result, i_dstsize, n;
    unsigned char *psz_dst;
    z_stream d_stream;

    d_stream.zalloc = (alloc_func)0;
    d_stream.zfree = (free_func)0;
    d_stream.opaque = (voidpf)0;

    i_result = inflateInit(&d_stream);
    if( i_result != Z_OK )
        return( -1 );
#if 0
    p_playlist->pp_items[p_playlist->i_index]->b_autodeletion = VLC_TRUE;
    i_position = p_playlist->i_index;

    /* Gather the complete sdp file */
    for( ;; )
    {
        int i_read = stream_Read( p_demux->s, &p_sdp[i_sdp], i_sdp_max - i_sdp - 1 );
#endif
    d_stream.next_in = (Bytef *)psz_src;
    d_stream.avail_in = i_len;
    n = 0;

    psz_dst = NULL;

    do
    {
        n++;
        psz_dst = (unsigned char *)realloc( psz_dst, n * 1000 );
        d_stream.next_out = (Bytef *)&psz_dst[(n - 1) * 1000];
        d_stream.avail_out = 1000;

        i_result = inflate(&d_stream, Z_NO_FLUSH);
        if( ( i_result != Z_OK ) && ( i_result != Z_STREAM_END ) )
        {
            inflateEnd( &d_stream );
            return( -1 );
        }
    }
    while( ( d_stream.avail_out == 0 ) && ( d_stream.avail_in != 0 ) &&
           ( i_result != Z_STREAM_END ) );

    i_dstsize = d_stream.total_out;
    inflateEnd( &d_stream );

    *_dst = (unsigned char *)realloc( psz_dst, i_dstsize );

    return i_dstsize;
}
#endif


static void FreeSDP( sdp_t *p_sdp )
{
    int i;
    FREE( p_sdp->psz_sdp );
    FREE( p_sdp->psz_sessionname );
    FREE( p_sdp->psz_connection );
    FREE( p_sdp->psz_media );
    FREE( p_sdp->psz_uri );
    FREE( p_sdp->psz_username );
    FREE( p_sdp->psz_network_type );

    FREE( p_sdp->psz_address );
    FREE( p_sdp->psz_address_type );

    for( i= p_sdp->i_attributes - 1; i >= 0 ; i-- )
    {
        struct attribute_t *p_attr = p_sdp->pp_attributes[i];
        FREE( p_sdp->pp_attributes[i]->psz_field );
        FREE( p_sdp->pp_attributes[i]->psz_value );
        REMOVE_ELEM( p_sdp->pp_attributes, p_sdp->i_attributes, i);
        FREE( p_attr );
    }
    FREE( p_sdp );
}

static int RemoveAnnounce( services_discovery_t *p_sd,
                           sap_announce_t *p_announce )
{
    int i;

    if( p_announce->p_sdp )
    {
        FreeSDP( p_announce->p_sdp );
        p_announce->p_sdp = NULL;
    }

    if( p_announce->i_item_id > -1 )
    {
        playlist_LockDelete( p_sd->p_sys->p_playlist, p_announce->i_item_id );
    }

    for( i = 0; i< p_sd->p_sys->i_announces; i++)
    {
        if( p_sd->p_sys->pp_announces[i] == p_announce )
        {
            REMOVE_ELEM( p_sd->p_sys->pp_announces, p_sd->p_sys->i_announces,
                         i);
            break;
        }
    }

    free( p_announce );

    return VLC_SUCCESS;
}

static vlc_bool_t IsSameSession( sdp_t *p_sdp1, sdp_t *p_sdp2 )
{
    /* A session is identified by
     * username, session_id, network type, address type and address */
    if( p_sdp1->psz_username && p_sdp2->psz_username &&
        p_sdp1->psz_network_type && p_sdp2->psz_network_type &&
        p_sdp1->psz_address_type && p_sdp2->psz_address_type &&
        p_sdp1->psz_address &&  p_sdp2->psz_address )
    {
        if(!strcmp( p_sdp1->psz_username , p_sdp2->psz_username ) &&
           !strcmp( p_sdp1->psz_network_type , p_sdp2->psz_network_type ) &&
           !strcmp( p_sdp1->psz_address_type , p_sdp2->psz_address_type ) &&
           !strcmp( p_sdp1->psz_address , p_sdp2->psz_address ) &&
           p_sdp1->i_session_id == p_sdp2->i_session_id )
        {
            return VLC_TRUE;
        }
        else
        {
            return VLC_FALSE;
        }
    }
    else
    {
        return VLC_FALSE;
    }
}