/*

 * Copyright (C) 2009 Nokia Corporation.

 * Copyright (C) 2007, 2008 OpenedHand Ltd.

 *

 * Authors: Zeeshan Ali (Khattak) <zeeshan.ali@nokia.com>

 *                                <zeeshanak@gnome.org>

 *          Jorn Baayen <jorn@openedhand.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gupnp-protocol-info

 * @short_description: UPnP AV ProtocolInfo

 *

 * #GUPnPProtocolInfo provides a convenient API to deal with ProtocolInfo

 * strings used in UPnP AV specifications.

 */

#include <string.h>

#include <stdlib.h>

#include "gupnp-protocol-info.h"

#include "gupnp-av-error.h"

G_DEFINE_TYPE (GUPnPProtocolInfo,

               gupnp_protocol_info,

               G_TYPE_OBJECT);

struct _GUPnPProtocolInfoPrivate {

        char  *protocol;

        char  *network;

        char  *mime_type;

        char  *dlna_profile;

        char **play_speeds;

        GUPnPDLNAConversion dlna_conversion;

        GUPnPDLNAOperation  dlna_operation;

        GUPnPDLNAFlags      dlna_flags;

};

enum {

        PROP_0,

        PROP_PROTOCOL,

        PROP_NETWORK,

        PROP_MIME_TYPE,

        PROP_DLNA_PROFILE,

        PROP_PLAY_SPEEDS,

        PROP_DLNA_CONVERSION,

        PROP_DLNA_OPERATION,

        PROP_DLNA_FLAGS

};

static void

parse_additional_info (const char        *additional_info,

                       GUPnPProtocolInfo *info)

{

        char **tokens = NULL;

        short i;

        if (strcmp (additional_info, "*") == 0)

                return;

        tokens = g_strsplit (additional_info, ";", -1);

        if (tokens == NULL) {

                g_warning ("Invalid additional info in DIDL-Lite info: %s",

                           additional_info);

                return;

        }

        for (i = 0; tokens[i]; i++) {

                char *p;

                p = g_strstr_len (tokens[i],

                                  strlen (tokens[i]),

                                  "DLNA.ORG_PN=");

                if (p != NULL) {

                        p += 12; /* end of "DLNA.ORG_PN=" */

                        gupnp_protocol_info_set_dlna_profile (info, p);

                        continue;

                }

                p = g_strstr_len (tokens[i],

                                  strlen (tokens[i]),

                                  "DLNA.ORG_PS=");

                if (p != NULL) {

                        char **play_speeds;

                        p += 12; /* end of "DLNA.ORG_PS=" */

                        play_speeds = g_strsplit (p, ",", -1);

                        gupnp_protocol_info_set_play_speeds

                                                (info,

                                                 (const char **) play_speeds);

                        g_strfreev (play_speeds);

                        continue;

                }

                p = g_strstr_len (tokens[i],

                                  strlen (tokens[i]),

                                  "DLNA.ORG_CI=");

                if (p != NULL) {

                        p += 12; /* end of "DLNA.ORG_CI=" */

                        gupnp_protocol_info_set_dlna_conversion (info,

                                                                 atoi (p));

                        continue;

                }

                p = g_strstr_len (tokens[i],

                                  strlen (tokens[i]),

                                  "DLNA.ORG_OP=");

                if (p != NULL) {

                        p += 12; /* end of "DLNA.ORG_OP=" */

                        gupnp_protocol_info_set_dlna_operation

                                                        (info,

                                                         strtoul (p, NULL, 16));

                        continue;

                }

                p = g_strstr_len (tokens[i],

                                  strlen (tokens[i]),

                                  "DLNA.ORG_FLAGS=");

                if (p != NULL) {

                        p += 15; /* end of "DLNA.ORG_FLAGS=" */

                        if (strlen (p) > 8)

                                p[8] = '\0';

                        gupnp_protocol_info_set_dlna_flags

                                                        (info,

                                                         strtoul (p, NULL, 16));

                        continue;

                }

        }

        g_strfreev (tokens);

}

static gboolean

is_transport_compat (GUPnPProtocolInfo *info1,

                     GUPnPProtocolInfo *info2)

{

        const char *protocol1;

        const char *protocol2;

        protocol1 = gupnp_protocol_info_get_protocol (info1);

        protocol2 = gupnp_protocol_info_get_protocol (info2);

        if (protocol1[0] != '*' &&

            protocol2[0] != '*' &&

            g_ascii_strcasecmp (protocol1, protocol2) != 0)

                return FALSE;

        else if (g_ascii_strcasecmp ("internal", protocol1) == 0 &&

                 strcmp (gupnp_protocol_info_get_network (info1),

                         gupnp_protocol_info_get_network (info2)) != 0)

                /* Host must be the same in case of INTERNAL protocol */

                return FALSE;

        else

                return TRUE;

}

static gboolean

is_content_format_compat (GUPnPProtocolInfo *info1,

                          GUPnPProtocolInfo *info2)

{

        const char *mime_type1;

        const char *mime_type2;

        mime_type1 = gupnp_protocol_info_get_mime_type (info1);

        mime_type2 = gupnp_protocol_info_get_mime_type (info2);

        if (mime_type1 [0] != '*' &&

            mime_type2 [0] != '*' &&

            g_ascii_strcasecmp (mime_type1, mime_type2) != 0 &&

            /* Handle special case for LPCM: It is the only content type that

             * make use of mime-type parameters that we know of.

             *

             * Example: audio/L16;rate=44100;channels=2

             */

            !((g_ascii_strcasecmp (mime_type1, "audio/L16") == 0 &&

               g_ascii_strncasecmp (mime_type2, "audio/L16", 9) == 0) ||

              (g_ascii_strcasecmp (mime_type2, "audio/L16") == 0 &&

               g_ascii_strncasecmp (mime_type1, "audio/L16", 9) == 0)))

                return FALSE;

        else

                return TRUE;

}

static gboolean

is_additional_info_compat (GUPnPProtocolInfo *info1,

                           GUPnPProtocolInfo *info2)

{

        const char *profile1;

        const char *profile2;

        profile1 = gupnp_protocol_info_get_dlna_profile (info1);

        profile2 = gupnp_protocol_info_get_dlna_profile (info2);

        if (profile1 == NULL ||

            profile2 == NULL ||

            profile1 [0] == '*' ||

            profile2 [0] == '*' ||

            g_ascii_strcasecmp (profile1, profile2) == 0)

                return TRUE;

        else

                return FALSE;

}

static void

add_dlna_info (GString           *str,

               GUPnPProtocolInfo *info)

{

        const char *dlna_profile;

        const char **speeds;

        GUPnPDLNAConversion conversion;

        GUPnPDLNAOperation operation;

        GUPnPDLNAFlags flags;

        dlna_profile = gupnp_protocol_info_get_dlna_profile (info);

        if (dlna_profile == NULL) {

                g_string_append_printf (str, ":");

        } else {

                g_string_append_printf (str, ":DLNA.ORG_PN=%s;", dlna_profile);

        }

        operation = gupnp_protocol_info_get_dlna_operation (info);

        if (operation != GUPNP_DLNA_OPERATION_NONE &&

            /* the OP parameter is only allowed for the "http-get"

             * and "rtsp-rtp-udp" protocols

             */

            (strcmp (gupnp_protocol_info_get_protocol (info),

                     "http-get") == 0 ||

             strcmp (gupnp_protocol_info_get_protocol (info),

                     "rtsp-rtp-udp") == 0))

                g_string_append_printf (str, "DLNA.ORG_OP=%.2x;", operation);

        /* Specify PS parameter if list of play speeds is provided */

        speeds = gupnp_protocol_info_get_play_speeds (info);

        if (speeds != NULL) {

                int i;

                g_string_append (str, "DLNA.ORG_PS=");

                for (i = 0; speeds[i]; i++) {

                        g_string_append (str, speeds[i]);

                        if (speeds[i + 1])

                                g_string_append_c (str, ',');

                }

                g_string_append_c (str, ';');

        }

        conversion = gupnp_protocol_info_get_dlna_conversion (info);

        /* omit the CI parameter for non-converted content */

        if (conversion != GUPNP_DLNA_CONVERSION_NONE)

                g_string_append_printf (str, "DLNA.ORG_CI=%d;", conversion);

        flags = gupnp_protocol_info_get_dlna_flags (info);

        /* Omit the FLAGS parameter if no or DLNA profile are set */

        if (flags != GUPNP_DLNA_FLAGS_NONE && dlna_profile != NULL) {

                g_string_append_printf (str, "DLNA.ORG_FLAGS=%.8x", flags);

                /*  append 24 reserved hex-digits */

                g_string_append_printf (str,

                                        "0000" "0000" "0000"

                                        "0000" "0000" "0000");

        }

        /* if nothing of the above was set, use the "match all" rule */

        switch (str->str[str->len - 1]) {

                case ':':

                        g_string_append_c (str, '*');

                        break;

                case ';':

                        g_string_erase (str, str->len - 1, 1);

                        break;

                default:

                        break;

        }

}

static void

gupnp_protocol_info_init (GUPnPProtocolInfo *info)

{

        info->priv = G_TYPE_INSTANCE_GET_PRIVATE

                                        (info,

                                         GUPNP_TYPE_PROTOCOL_INFO,

                                         GUPnPProtocolInfoPrivate);

        info->priv->dlna_conversion = GUPNP_DLNA_CONVERSION_NONE;

        info->priv->dlna_operation  = GUPNP_DLNA_OPERATION_NONE;

        info->priv->dlna_flags      = GUPNP_DLNA_FLAGS_NONE;

}

static void

gupnp_protocol_info_set_property (GObject      *object,

                                  guint         property_id,

                                  const GValue *value,

                                  GParamSpec   *pspec)

{

        GUPnPProtocolInfo *info;

        info = GUPNP_PROTOCOL_INFO (object);

        switch (property_id) {

        case PROP_PROTOCOL:

                gupnp_protocol_info_set_protocol (info,

                                                  g_value_get_string (value));

                break;

        case PROP_NETWORK:

                gupnp_protocol_info_set_network (info,

                                                 g_value_get_string (value));

                break;

        case PROP_MIME_TYPE:

                gupnp_protocol_info_set_mime_type (info,

                                                   g_value_get_string (value));

                break;

        case PROP_DLNA_PROFILE:

                gupnp_protocol_info_set_dlna_profile

                                        (info,

                                         g_value_get_string (value));

                break;

        case PROP_PLAY_SPEEDS:

                gupnp_protocol_info_set_play_speeds (info,

                                                     g_value_get_boxed (value));

                break;

        case PROP_DLNA_CONVERSION:

                gupnp_protocol_info_set_dlna_conversion

                                        (info,

                                         g_value_get_flags (value));

                break;

        case PROP_DLNA_OPERATION:

                gupnp_protocol_info_set_dlna_operation

                                        (info,

                                         g_value_get_flags (value));

                break;

        case PROP_DLNA_FLAGS:

                gupnp_protocol_info_set_dlna_flags

                                        (info,

                                         g_value_get_flags (value));

                break;

        default:

                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

                break;

        }

}

static void

gupnp_protocol_info_get_property (GObject    *object,

                                  guint       property_id,

                                  GValue     *value,

                                  GParamSpec *pspec)

{

        GUPnPProtocolInfo *info;

        info = GUPNP_PROTOCOL_INFO (object);

        switch (property_id) {

        case PROP_PROTOCOL:

                g_value_set_string (value,

                                    gupnp_protocol_info_get_protocol (info));

                break;

        case PROP_NETWORK:

                g_value_set_string (value,

                                    gupnp_protocol_info_get_network (info));

                break;

        case PROP_MIME_TYPE:

                g_value_set_string (value,

                                    gupnp_protocol_info_get_mime_type (info));

                break;

        case PROP_DLNA_PROFILE:

                g_value_set_string

                              (value,

                               gupnp_protocol_info_get_dlna_profile (info));

                break;

        case PROP_PLAY_SPEEDS:

                g_value_set_boxed (value,

                                   gupnp_protocol_info_get_play_speeds (info));

                break;

        case PROP_DLNA_CONVERSION:

                g_value_set_flags

                                (value,

                                 gupnp_protocol_info_get_dlna_conversion

                                                                (info));

                break;

        case PROP_DLNA_OPERATION:

                g_value_set_flags

                                (value,

                                 gupnp_protocol_info_get_dlna_operation (info));

                break;

        case PROP_DLNA_FLAGS:

                g_value_set_flags (value,

                                   gupnp_protocol_info_get_dlna_flags (info));

                break;

        default:

                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

                break;

        }

}

static void

gupnp_protocol_info_finalize (GObject *object)

{

        GObjectClass                 *object_class;

        GUPnPProtocolInfoPrivate *priv;

        priv = GUPNP_PROTOCOL_INFO (object)->priv;

        if (priv->protocol)

                g_free (priv->protocol);

        if (priv->network)

                g_free (priv->network);

        if (priv->mime_type)

                g_free (priv->mime_type);

        if (priv->dlna_profile)

                g_free (priv->dlna_profile);

        if (priv->play_speeds)

                g_strfreev (priv->play_speeds);

        object_class = G_OBJECT_CLASS (gupnp_protocol_info_parent_class);

        object_class->finalize (object);

}

static void

gupnp_protocol_info_class_init (GUPnPProtocolInfoClass *klass)

{

        GObjectClass *object_class;

        object_class = G_OBJECT_CLASS (klass);

        object_class->set_property = gupnp_protocol_info_set_property;

        object_class->get_property = gupnp_protocol_info_get_property;

        object_class->finalize = gupnp_protocol_info_finalize;

        g_type_class_add_private (klass, sizeof (GUPnPProtocolInfoPrivate));

        /**

         * GUPnPProtocolInfo:protocol:

         *

         * The protocol of this info.

         **/

        g_object_class_install_property

                (object_class,

                 PROP_PROTOCOL,

                 g_param_spec_string ("protocol",

                                      "Protocol",

                                      "The protocol of this info.",

                                      NULL,

                                      G_PARAM_READWRITE |

                                      G_PARAM_STATIC_NAME |

                                      G_PARAM_STATIC_NICK |

                                      G_PARAM_STATIC_BLURB));

        /**

         * GUPnPProtocolInfo:network:

         *

         * The network this info is associated with.

         **/

        g_object_class_install_property

                (object_class,

                 PROP_NETWORK,

                 g_param_spec_string ("network",

                                      "Network",

                                      "The network this info is associated"

                                      " with.",

                                      NULL,

                                      G_PARAM_READWRITE |

                                      G_PARAM_STATIC_NAME |

                                      G_PARAM_STATIC_NICK |

                                      G_PARAM_STATIC_BLURB));

        /**

         * GUPnPProtocolInfo:mime-type:

         *

         * The MIME-type of this info.

         **/

        g_object_class_install_property

                (object_class,

                 PROP_MIME_TYPE,

                 g_param_spec_string ("mime-type",

                                      "MIMEType",

                                      "The MIME-type of this info.",

                                      NULL,

                                      G_PARAM_READWRITE |

                                      G_PARAM_STATIC_NAME |

                                      G_PARAM_STATIC_NICK |

                                      G_PARAM_STATIC_BLURB));

        /**

         * GUPnPProtocolInfo:dlna-profile:

         *

         * The DLNA profile of this info.

         **/

        g_object_class_install_property

                (object_class,

                 PROP_DLNA_PROFILE,

                 g_param_spec_string ("dlna-profile",

                                      "DLNAProfile",

                                      "The DLNA profile of this info.",

                                      NULL,

                                      G_PARAM_READWRITE |

                                      G_PARAM_STATIC_NAME |

                                      G_PARAM_STATIC_NICK |

                                      G_PARAM_STATIC_BLURB));

        /**

         * GUPnPProtocolInfo:play-speeds:

         *

         * The allowed play speeds on this info in the form of array of

         * strings.

         **/

        g_object_class_install_property

                (object_class,

                 PROP_PLAY_SPEEDS,

                 g_param_spec_boxed ("play-speeds",

                                     "PlaySpeeds",

                                     "The allowed play speeds on this"

                                     " info in the form of array of"

                                     " strings.",

                                     G_TYPE_STRV,

                                     G_PARAM_READWRITE |

                                     G_PARAM_STATIC_NAME |

                                     G_PARAM_STATIC_NICK |

                                     G_PARAM_STATIC_BLURB));

        /**

         * GUPnPProtocolInfo:dlna-conversion:

         *

         * The DLNA conversion flags.

         **/

        g_object_class_install_property

                (object_class,

                 PROP_DLNA_CONVERSION,

                 g_param_spec_flags ("dlna-conversion",

                                     "DLNAConversion",

                                     "The DLNA conversion flags.",

                                     GUPNP_TYPE_DLNA_CONVERSION,

                                     GUPNP_DLNA_CONVERSION_NONE,

                                     G_PARAM_READWRITE |

                                     G_PARAM_STATIC_NAME |

                                     G_PARAM_STATIC_NICK |

                                     G_PARAM_STATIC_BLURB));

        /**

         * GUPnPProtocolInfo:dlna-operation:

         *

         * The DLNA operation flags.

         **/

        g_object_class_install_property

                (object_class,

                 PROP_DLNA_OPERATION,

                 g_param_spec_flags ("dlna-operation",

                                     "DLNAOperation",

                                     "The DLNA operation flags.",

                                     GUPNP_TYPE_DLNA_OPERATION,

                                     GUPNP_DLNA_OPERATION_NONE,

                                     G_PARAM_READWRITE |

                                     G_PARAM_STATIC_NAME |

                                     G_PARAM_STATIC_NICK |

                                     G_PARAM_STATIC_BLURB));

        /**

         * GUPnPProtocolInfo:dlna-flags:

         *

         * Various generic DLNA flags.

         **/

        g_object_class_install_property

                (object_class,

                 PROP_DLNA_FLAGS,

                 g_param_spec_flags ("dlna-flags",

                                     "DLNAFlags",

                                     "Various generic DLNA flags.",

                                     GUPNP_TYPE_DLNA_FLAGS,

                                     GUPNP_DLNA_FLAGS_NONE,

                                     G_PARAM_READWRITE |

                                     G_PARAM_STATIC_NAME |

                                     G_PARAM_STATIC_NICK |

                                     G_PARAM_STATIC_BLURB));

}

/**

 * gupnp_protocol_info_new:

 *

 * Return value: A new #GUPnPProtocolInfo object. Unref after usage.

 **/

GUPnPProtocolInfo *

gupnp_protocol_info_new (void)

{

        return g_object_new (GUPNP_TYPE_PROTOCOL_INFO,

                             NULL);

}

/**

 * gupnp_protocol_info_new_from_string:

 * @protocol_info: The protocol info string

 * @error: The location where to store any error, or NULL

 *

 * Parses the @protocol_info string and creates a new #GUPnPProtocolInfo object

 * as a result.

 *

 * Return value: A new #GUPnPProtocolInfo object. Unref after usage.

 **/

GUPnPProtocolInfo *

gupnp_protocol_info_new_from_string (const char *protocol_info,

                                     GError    **error)

{

        GUPnPProtocolInfo *info;

        char **tokens;

        g_return_val_if_fail (protocol_info != NULL, NULL);

        tokens = g_strsplit (protocol_info, ":", 4);

        if (tokens[0] == NULL ||

            tokens[1] == NULL ||

            tokens[2] == NULL ||

            tokens[3] == NULL) {

                g_set_error (error,

                             GUPNP_PROTOCOL_ERROR,

                             GUPNP_PROTOCOL_ERROR_INVALID_SYNTAX,

                             "Failed to parse protocolInfo string: \n%s",

                             protocol_info);

                g_strfreev (tokens);

                return NULL;

        }

        info = gupnp_protocol_info_new ();

        gupnp_protocol_info_set_protocol (info, tokens[0]);

        gupnp_protocol_info_set_network (info, tokens[1]);

        gupnp_protocol_info_set_mime_type (info, tokens[2]);

        parse_additional_info (tokens[3], info);

        g_strfreev (tokens);

        return info;

}

/**

 * gupnp_protocol_info_to_string:

 * @info: The #GUPnPProtocolInfo

 *

 * Provides the string representation of @info.

 *

 * Return value: String representation of @info. #g_free after usage.

 **/

char *

gupnp_protocol_info_to_string (GUPnPProtocolInfo *info)

{

        GString *str;

        const char *protocol;

        const char *mime_type;

        const char *network;

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL);

        protocol = gupnp_protocol_info_get_protocol (info);

        mime_type = gupnp_protocol_info_get_mime_type (info);

        network = gupnp_protocol_info_get_network (info);

        g_return_val_if_fail (protocol != NULL, NULL);

        g_return_val_if_fail (mime_type != NULL, NULL);

        str = g_string_new ("");

        g_string_append (str, protocol);

        g_string_append_c (str, ':');

        if (network != NULL)

                g_string_append (str, network);

        else

                g_string_append_c (str, '*');

        g_string_append_c (str, ':');

        g_string_append (str, mime_type);

        add_dlna_info (str, info);

        return g_string_free (str, FALSE);

}

/**

 * gupnp_protocol_info_get_protocol:

 * @info: A #GUPnPProtocolInfo

 *

 * Get the protocol of this info.

 *

 * Return value: The protocol of this info or %NULL. This string should not

 * be freed.

 **/

const char *

gupnp_protocol_info_get_protocol (GUPnPProtocolInfo *info)

{

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL);

        return info->priv->protocol;

}

/**

 * gupnp_protocol_info_get_network:

 * @info: A #GUPnPProtocolInfo

 *

 * Get the network this info is associated with.

 *

 * Return value: The network string or %NULL. This string should not be freed.

 **/

const char *

gupnp_protocol_info_get_network (GUPnPProtocolInfo *info)

{

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL);

        return info->priv->network;

}

/**

 * gupnp_protocol_info_get_mime_type:

 * @info: A #GUPnPProtocolInfo

 *

 * Get the MIME-type of this info.

 *

 * Return value: The MIME-type of this info or %NULL. This string should not

 * be freed.

 **/

const char *

gupnp_protocol_info_get_mime_type (GUPnPProtocolInfo *info)

{

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL);

        return info->priv->mime_type;

}

/**

 * gupnp_protocol_info_get_dlna_profile:

 * @info: A #GUPnPProtocolInfo

 *

 * Get the DLNA profile of this info.

 *

 * Return value: The DLNA profile of this info or %NULL. This string should

 * not be freed.

 **/

const char *

gupnp_protocol_info_get_dlna_profile (GUPnPProtocolInfo *info)

{

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL);

        return info->priv->dlna_profile;

}

/**

 * gupnp_protocol_info_get_play_speeds:

 * @info: A #GUPnPProtocolInfo

 *

 * Get the allowed play speeds on this info in the form of array of strings.

 *

 * Returns: (transfer none): The allowed play speeds as array of strings or %NULL. This

 * return array and it's content must not be modified or freed.

 **/

const char **

gupnp_protocol_info_get_play_speeds (GUPnPProtocolInfo *info)

{

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL);

        return (const char **) info->priv->play_speeds;

}

/**

 * gupnp_protocol_info_get_dlna_conversion:

 * @info: A #GUPnPProtocolInfo

 *

 * Get the DLNA conversion flags.

 *

 * Return value: The DLNA conversion flags.

 **/

GUPnPDLNAConversion

gupnp_protocol_info_get_dlna_conversion (GUPnPProtocolInfo *info)

{

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info),

                              GUPNP_DLNA_CONVERSION_NONE);

        return info->priv->dlna_conversion;

}

/**

 * gupnp_protocol_info_get_dlna_operation:

 * @info: A #GUPnPProtocolInfo

 *

 * Get the DLNA operation flags.

 *

 * Return value: The DLNA operation flags.

 **/

GUPnPDLNAOperation

gupnp_protocol_info_get_dlna_operation (GUPnPProtocolInfo *info)

{

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info),

                              GUPNP_DLNA_OPERATION_NONE);

        return info->priv->dlna_operation;

}

/**

 * gupnp_protocol_info_get_dlna_flags:

 * @info: A #GUPnPProtocolInfo

 *

 * Get the gereric DLNA flags.

 *

 * Return value: The generic DLNA flags.

 **/

GUPnPDLNAFlags

gupnp_protocol_info_get_dlna_flags (GUPnPProtocolInfo *info)

{

        g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info),

                              GUPNP_DLNA_FLAGS_NONE);

        return info->priv->dlna_flags;

}

/**

 * gupnp_protocol_info_set_protocol:

 * @info: A #GUPnPProtocolInfo

 * @protocol: The protocol string

 *

 * Set the protocol of this info.

 **/

void

gupnp_protocol_info_set_protocol (GUPnPProtocolInfo *info,

                                  const char        *protocol)

{

        g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info));

        if (info->priv->protocol)

                g_free (info->priv->protocol);

        info->priv->protocol = g_strdup (protocol);

        g_object_notify (G_OBJECT (info), "protocol");

}

/**

 * gupnp_protocol_info_set_network:

 * @info: A #GUPnPProtocolInfo

 * @network: The network string

 *

 * Set the network this info is associated with.

 **/

void

gupnp_protocol_info_set_network (GUPnPProtocolInfo *info,

                                 const char        *network)

{

        g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info));

        if (info->priv->network)

                g_free (info->priv->network);

        info->priv->network = g_strdup (network);

        g_object_notify (G_OBJECT (info), "network");

}

/**

 * gupnp_protocol_info_set_mime_type:

 * @info: A #GUPnPProtocolInfo

 * @mime_type: The MIME-type string

 *

 * Set the MIME-type of this info.