Untitled

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#define _GNU_SOURCE
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include <glib.h>

#include <ofono/log.h>
#include <ofono/modem.h>
#include <ofono/netreg.h>
#include <ofono/spn-table.h>

#include "common.h"
#include "gril.h"

#include "grilreply.h"
#include "grilrequest.h"
#include "grilunsol.h"
#include <ofono/netreg.h>
static void ril_network_state_change(struct ril_msg *message,
                            gpointer user_data)
{
    struct ofono_netreg *netreg = user_data;
    struct netreg_data *nd = ofono_netreg_get_data(netreg);

    g_ril_print_unsol_no_args(nd->ril, message);

    ril_registration_status(netreg, NULL, NULL);
}

static void ril_strength_notify(struct ril_msg *message, gpointer user_data)
{
    struct ofono_netreg *netreg = user_data;
    struct netreg_data *nd = ofono_netreg_get_data(netreg);
    int strength = g_ril_unsol_parse_signal_strength(nd->ril, message,
                                nd->tech);

    ofono_netreg_strength_notify(netreg, strength);
}

static void ril_nitz_notify(struct ril_msg *message, gpointer user_data)
{
    struct ofono_netreg *netreg = user_data;
    struct netreg_data *nd = ofono_netreg_get_data(netreg);
    int year, mon, mday, hour, min, sec, dst, tzi, n_match;
    char tzs, tz[4];
    gchar *nitz;

    nitz = g_ril_unsol_parse_nitz(nd->ril, message);
    if (nitz == NULL)
        goto error;

    n_match = sscanf(nitz, "%u/%u/%u,%u:%u:%u%c%u,%u", &year, &mon,
                &mday, &hour, &min, &sec, &tzs, &tzi, &dst);
    if (n_match != 9)
        goto error;

    sprintf(tz, "%c%d", tzs, tzi);

    nd->time.utcoff = atoi(tz) * 15 * 60;
    nd->time.dst = dst;
    nd->time.sec = sec;
    nd->time.min = min;
    nd->time.hour = hour;
    nd->time.mday = mday;
    nd->time.mon = mon;
    nd->time.year = 2000 + year;

    ofono_netreg_time_notify(netreg, &nd->time);

    g_free(nitz);

    return;

error:
    ofono_error("%s: unable to notify ofono about NITZ (%s)",
                        __func__, nitz ? nitz : "null");
    g_free(nitz);
}

static gboolean ril_delayed_register(gpointer user_data)
{
    struct ofono_netreg *netreg = user_data;
    struct netreg_data *nd = ofono_netreg_get_data(netreg);
    ofono_netreg_register(netreg);

    /* Register for network state changes */
    g_ril_register(nd->ril, RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
            ril_network_state_change, netreg);

    /* Register for network time update reports */
    g_ril_register(nd->ril, RIL_UNSOL_NITZ_TIME_RECEIVED,
            ril_nitz_notify, netreg);

    /* Register for signal strength changes */
    g_ril_register(nd->ril, RIL_UNSOL_SIGNAL_STRENGTH,
            ril_strength_notify, netreg);

    g_ril_register(nd->ril, MTK2_RIL_UNSOL_RESPONSE_REGISTRATION_SUSPENDED,
            mtk2_reg_suspended, netreg);

    /* This makes the timeout a single-shot */
    return FALSE;
}


struct mtk2_ril_data {
    GRil *ril;
    enum ofono_ril_vendor vendor;
    int sim_status_retries;
    ofono_bool_t init_state;
    ofono_bool_t ofono_online;
    int radio_state;
    struct ofono_sim *sim;
    int rild_connect_retries;
    GRilMsgIdToStrFunc request_id_to_string;
    GRilMsgIdToStrFunc unsol_request_to_string;
    ril_get_driver_type_func get_driver_type;
    struct cb_data *set_online_cbd;
    int suspend_id;
}

static void mtk2_reg_suspended(struct ril_msg *message, gpointer user_data)
{
    struct ofono_modem *modem = user_data;
    struct mtk2_ril_data *md = ofono_modem_get_data(modem);
    struct parcel rilp;
    int session_id;

    session_id = g_mtk2_unsol_parse_registration_suspended(md->ril, message);
    if (session_id < 0) {
        ofono_error("%s: parse error", __func__);
        return;
    }

    g_mtk2_request_resume_registration(md->ril, session_id, &rilp);
}

void g_mtk2_request_resume_registration(GRil *gril, int session_id,
                    struct parcel *rilp)
{
    parcel_init(rilp);
    parcel_w_int32(rilp, 1);
    parcel_w_int32(rilp, session_id);

    g_ril_append_print_buf(gril, "(%d)", session_id);
}

int g_mtk2_unsol_parse_registration_suspended(GRil *gril,
                        const struct ril_msg *message)
{
    struct parcel rilp;
    int numint, session_id;

    g_ril_init_parcel(message, &rilp);

    numint = parcel_r_int32(&rilp);
    if (numint != 1) {
        ofono_error("%s Wrong format", __func__);
        goto error;
    }

    session_id = parcel_r_int32(&rilp);

    if (rilp.malformed) {
        ofono_error("%s: malformed parcel", __func__);
        goto error;
    }

    g_ril_append_print_buf(gril, "{%d}", session_id);
    g_ril_print_unsol(gril, message);

    return session_id;

error:
    return -1;

}