static int businit(void)
{
gn_error err;
if ((err = gn_lib_phoneprofile_load_from_file(configfile, configmodel, &state)) != GN_ERR_NONE) {
fprintf(stderr, "%s\n", gn_error_print(err));
if (configfile)
fprintf(stderr, _("File: %s\n"), configfile);
if (configmodel)
fprintf(stderr, _("Phone section: [phone_%s]\n"), configmodel);
return 2;
}
/* register cleanup function */
atexit(busterminate);
/* signal(SIGINT, bussignal); */
if (install_log_handler()) {
fprintf(stderr, _("WARNING: cannot open logfile, logs will be directed to stderr\n"));
}
if ((err = gn_lib_phone_open(state)) != GN_ERR_NONE) {
fprintf(stderr, "%s\n", gn_error_print(err));
return 2;
}
data = &state->sm_data;
return 0;
}
gn_error sendringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_sms sms;
gn_error error = GN_ERR_NOTSUPPORTED;
gn_sms_default_submit(&sms);
sms.user_data[0].type = GN_SMS_DATA_Ringtone;
sms.user_data[1].type = GN_SMS_DATA_None;
if ((error = gn_file_ringtone_read(optarg, &sms.user_data[0].u.ringtone))) {
fprintf(stderr, _("Failed to load ringtone: %s\n"), gn_error_print(error));
return error;
}
/* The second argument is the destination, ie the phone number of recipient. */
snprintf(sms.remote.number, sizeof(sms.remote.number) - 1, "%s", argv[optind]);
if (sms.remote.number[0] == '+')
sms.remote.type = GN_GSM_NUMBER_International;
else
sms.remote.type = GN_GSM_NUMBER_Unknown;
/* Get the SMS Center */
if (!sms.smsc.number[0]) {
data->message_center = calloc(1, sizeof(gn_sms_message_center));
data->message_center->id = 1;
if (gn_sm_functions(GN_OP_GetSMSCenter, data, state) == GN_ERR_NONE) {
snprintf(sms.smsc.number, sizeof(sms.smsc.number), "%s", data->message_center->smsc.number);
sms.smsc.type = data->message_center->smsc.type;
}
free(data->message_center);
}
if (!sms.smsc.type) sms.smsc.type = GN_GSM_NUMBER_Unknown;
/* Send the message. */
data->sms = &sms;
error = gn_sms_send(data, state);
if (error == GN_ERR_NONE) {
if (sms.parts > 1) {
int j;
fprintf(stderr, _("Message sent in %d parts with reference numbers:"), sms.parts);
for (j = 0; j < sms.parts; j++)
fprintf(stderr, " %d", sms.reference[j]);
fprintf(stderr, "\n");
} else
fprintf(stderr, _("Send succeeded with reference %d!\n"), sms.reference[0]);
} else
fprintf(stderr, _("SMS Send failed (%s)\n"), gn_error_print(error));
return error;
}
gn_error enterchar(gn_data *data, struct gn_statemachine *state)
{
unsigned char ch;
gn_error error = GN_ERR_NONE;
gn_data_clear(data);
console_raw();
while ((error = GN_ERR_NONE) && (read(0, &ch, 1) > 0)) {
switch (ch) {
case '\r':
break;
case '\n':
data->key_code = GN_KEY_MENU;
presskey(data, state);
break;
#ifdef WIN32
case '\033':
#else
case '\e':
#endif
data->key_code = GN_KEY_NAMES;
presskey(data, state);
break;
default:
data->character = ch;
error = gn_sm_functions(GN_OP_EnterChar, data, state);
if (error != GN_ERR_NONE)
fprintf(stderr, _("Error entering char: %s\n"), gn_error_print(error));
break;
}
}
return error;
}
gn_error deleteringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_ringtone ringtone;
gn_error error;
int i, start, end;
memset(&ringtone, 0, sizeof(ringtone));
gn_data_clear(data);
data->ringtone = &ringtone;
start = gnokii_atoi(optarg);
if (errno || start < 0)
return deleteringtone_usage(stderr, -1);
end = parse_end_value_option(argc, argv, optind, start);
if (errno || end < 0)
return deleteringtone_usage(stderr, -1);
for (i = start; i <= end; i++) {
ringtone.location = i;
if ((error = gn_sm_functions(GN_OP_DeleteRingtone, data, state)) == GN_ERR_NONE)
fprintf(stderr, _("Ringtone %d deleted\n"), i);
else
fprintf(stderr, _("Failed to delete ringtone %d: %s\n"), i, gn_error_print(error));
}
return GN_ERR_NONE;
}
gn_error getlocksinfo(gn_data *data, struct gn_statemachine *state)
{
gn_locks_info locks_info[4];
gn_error error;
char *locks_names[] = {"MCC+MNC", "GID1", "GID2", "MSIN"};
int i;
gn_data_clear(data);
data->locks_info = locks_info;
if ((error = gn_sm_functions(GN_OP_GetLocksInfo, data, state)) != GN_ERR_NONE) {
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
return error;
}
for (i = 0; i < 4; i++) {
fprintf(stdout, _("%7s : %10s, %7s, %6s, counter %d\n"),
locks_names[i],
locks_info[i].data,
locks_info[i].userlock ? "user" : "factory",
locks_info[i].closed ? "CLOSED" : "open",
locks_info[i].counter);
}
return GN_ERR_NONE;
}
/* Writes profiles to phone */
gn_error setprofile(gn_data *data, struct gn_statemachine *state)
{
int n;
gn_profile p;
gn_error error = GN_ERR_NONE;
char line[256], ch;
gn_data_clear(data);
data->profile = &p;
while (fgets(line, sizeof(line), stdin)) {
n = strlen(line);
if (n > 0 && line[n-1] == '\n') {
line[--n] = 0;
}
n = sscanf(line, "%d;%39[^;];%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d%c",
&p.number, p.name, &p.default_name, &p.keypad_tone,
&p.lights, &p.call_alert, &p.ringtone, &p.volume,
&p.message_tone, &p.vibration, &p.warning_tone,
&p.caller_groups, &p.automatic_answer, &ch);
if (n != 13) {
fprintf(stderr, _("Input line format isn't valid\n"));
return GN_ERR_WRONGDATAFORMAT;
}
error = gn_sm_functions(GN_OP_SetProfile, data, state);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Cannot set profile: %s\n"), gn_error_print(error));
return error;
}
}
return error;
}
gn_error loadbitmap(gn_bmp *bitmap, char *s, int type, struct gn_statemachine *state)
{
gn_error error;
bitmap->type = type;
error = gn_bmp_null(bitmap, &state->driver.phone);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Could not null bitmap: %s\n"), gn_error_print(error));
return error;
}
error = gn_file_bitmap_read(s, bitmap, &state->driver.phone);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Could not load bitmap from %s: %s\n"), s, gn_error_print(error));
return error;
}
return GN_ERR_NONE;
}
static gn_error presskey(gn_data *data, struct gn_statemachine *state)
{
gn_error error;
error = gn_sm_functions(GN_OP_PressPhoneKey, data, state);
if (error == GN_ERR_NONE)
error = gn_sm_functions(GN_OP_ReleasePhoneKey, data, state);
if (error != GN_ERR_NONE)
fprintf(stderr, _("Failed to press key: %s\n"), gn_error_print(error));
return error;
}
/* Deleting all ToDo notes */
gn_error deletealltodos(gn_data *data, struct gn_statemachine *state)
{
gn_error error;
gn_data_clear(data);
error = gn_sm_functions(GN_OP_DeleteAllToDos, data, state);
if (error == GN_ERR_NONE)
fprintf(stderr, _("Successfully deleted all ToDo notes!\n"));
else
fprintf(stderr, _("Failed to delete ToDo note: %s\n"), gn_error_print(error));
return error;
}
gn_error ringtoneconvert(int argc, char *argv[])
{
gn_ringtone ringtone;
gn_error error;
if (argc != optind + 1) {
return ringtoneconvert_usage(stderr, -1);
}
if ((error = gn_file_ringtone_read(optarg, &ringtone)) != GN_ERR_NONE) {
fprintf(stderr, _("Failed to load ringtone: %s\n"), gn_error_print(error));
return error;
}
if ((error = gn_file_ringtone_save(argv[optind], &ringtone)) != GN_ERR_NONE) {
fprintf(stderr, _("Failed to save ringtone: %s\n"), gn_error_print(error));
return error;
}
fprintf(stderr, _("%d note(s) converted.\n"), ringtone.notes_count);
return error;
}
/* Select the specified profile */
gn_error setactiveprofile(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_profile p;
gn_error error;
gn_data_clear(data);
data->profile = &p;
p.number = gnokii_atoi(optarg);
if (errno || p.number < 0)
return setactiveprofile_usage(stderr, -1);
error = gn_sm_functions(GN_OP_SetActiveProfile, data, state);
if (error != GN_ERR_NONE)
fprintf(stderr, _("Cannot set active profile to %d: %s\n"), p.number, gn_error_print(error));
return error;
}
gn_error changesecuritycode(char *type, gn_data *data, struct gn_statemachine *state)
{
gn_error error;
gn_security_code security_code;
char newcode2[10];
memset(&security_code, 0, sizeof(security_code));
if (!strcmp(type, "PIN"))
security_code.type = GN_SCT_Pin;
else if (!strcmp(type, "PUK"))
security_code.type = GN_SCT_Puk;
else if (!strcmp(type, "PIN2"))
security_code.type = GN_SCT_Pin2;
else if (!strcmp(type, "PUK2"))
security_code.type = GN_SCT_Puk2;
/* FIXME: Entering of security_code does not work :-(
else if (!strcmp(type, "security_code"))
security_code.type = GN_SCT_security_code;
*/
else
return changesecuritycode_usage(stderr, -1);
get_password(_("Enter your code: "), security_code.code, sizeof(security_code.code));
get_password(_("Enter new code: "), security_code.new_code, sizeof(security_code.new_code));
get_password(_("Retype new code: "), newcode2, sizeof(newcode2));
if (strcmp(security_code.new_code, newcode2)) {
fprintf(stderr, _("Error: new code differs\n"));
return GN_ERR_FAILED;
}
gn_data_clear(data);
data->security_code = &security_code;
error = gn_sm_functions(GN_OP_ChangeSecurityCode, data, state);
switch (error) {
case GN_ERR_NONE:
fprintf(stderr, _("Code changed.\n"));
break;
default:
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
break;
}
return error;
}
gn_error getsecuritycode(gn_data *data, struct gn_statemachine *state)
{
gn_error error;
gn_security_code sc;
memset(&sc, 0, sizeof(sc));
sc.type = GN_SCT_SecurityCode;
data->security_code = ≻
fprintf(stderr, _("Getting security code... \n"));
error = gn_sm_functions(GN_OP_GetSecurityCode, data, state);
switch (error) {
case GN_ERR_NONE:
fprintf(stdout, _("Security code is: %s\n"), sc.code);
break;
default:
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
break;
}
return error;
}
gn_error getsecuritycodestatus(gn_data *data, struct gn_statemachine *state)
{
gn_security_code security_code;
gn_error err;
gn_data_clear(data);
data->security_code = &security_code;
err = gn_sm_functions(GN_OP_GetSecurityCodeStatus, data, state);
if (err == GN_ERR_NONE) {
fprintf(stdout, _("Security code status: "));
switch(security_code.type) {
case GN_SCT_SecurityCode:
fprintf(stdout, _("waiting for Security Code.\n"));
break;
case GN_SCT_Pin:
fprintf(stdout, _("waiting for PIN.\n"));
break;
case GN_SCT_Pin2:
fprintf(stdout, _("waiting for PIN2.\n"));
break;
case GN_SCT_Puk:
fprintf(stdout, _("waiting for PUK.\n"));
break;
case GN_SCT_Puk2:
fprintf(stdout, _("waiting for PUK2.\n"));
break;
case GN_SCT_None:
fprintf(stdout, _("nothing to enter.\n"));
break;
default:
fprintf(stdout, _("unknown\n"));
break;
}
} else
fprintf(stderr, _("Error: %s\n"), gn_error_print(err));
return err;
}
/* Queries the active profile */
gn_error getactiveprofile(gn_data *data, struct gn_statemachine *state)
{
gn_profile p;
gn_error error;
gn_data_clear(data);
data->profile = &p;
error = gn_sm_functions(GN_OP_GetActiveProfile, data, state);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Cannot get active profile: %s\n"), gn_error_print(error));
return error;
}
error = gn_sm_functions(GN_OP_GetProfile, data, state);
if (error != GN_ERR_NONE)
fprintf(stderr, _("Cannot get profile %d\n"), p.number);
else
fprintf(stdout, _("Active profile: %d (%s)\n"), p.number, p.name);
return error;
}
gn_error getnetworkinfo(gn_data *data, struct gn_statemachine *state)
{
gn_network_info networkinfo;
gn_error error;
int lac, cid;
char country[4] = {0, 0, 0, 0};
gn_data_clear(data);
memset(&networkinfo, 0, sizeof(networkinfo));
data->network_info = &networkinfo;
state->callbacks.reg_notification = NULL;
data->callback_data = NULL;
if ((error = gn_sm_functions(GN_OP_GetNetworkInfo, data, state)) != GN_ERR_NONE) {
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
return error;
}
/* Ugly, ugly, ... */
if (networkinfo.cell_id[2] == 0 && networkinfo.cell_id[3] == 0)
cid = (networkinfo.cell_id[0] << 8) + networkinfo.cell_id[1];
else
cid = (networkinfo.cell_id[0] << 24) + (networkinfo.cell_id[1] << 16) + (networkinfo.cell_id[2] << 8) + networkinfo.cell_id[3];
lac = (networkinfo.LAC[0] << 8) + networkinfo.LAC[1];
memcpy(country, networkinfo.network_code, 3);
fprintf(stdout, _("Network : %s (%s)\n"),
gn_network_name_get((char *)networkinfo.network_code),
gn_country_name_get((char *)country));
fprintf(stdout, _("Network code : %s\n"), (*networkinfo.network_code ? networkinfo.network_code : _("undefined")));
fprintf(stdout, _("LAC : %04x (%d)\n"), lac, lac);
fprintf(stdout, _("Cell id : %08x (%d)\n"), cid, cid);
return GN_ERR_NONE;
}
/* In this mode we get the code from the keyboard and send it to the mobile
phone. */
gn_error entersecuritycode(char *type, gn_data *data, struct gn_statemachine *state)
{
gn_error error;
gn_security_code security_code;
if (!strcmp(type, "PIN"))
security_code.type = GN_SCT_Pin;
else if (!strcmp(type, "PUK"))
security_code.type = GN_SCT_Puk;
else if (!strcmp(type, "PIN2"))
security_code.type = GN_SCT_Pin2;
else if (!strcmp(type, "PUK2"))
security_code.type = GN_SCT_Puk2;
else if (!strcmp(type, "SEC"))
security_code.type = GN_SCT_SecurityCode;
else
return entersecuritycode_usage(stderr, -1);
memset(&security_code.code, 0, sizeof(security_code.code));
get_password(_("Enter your code: "), security_code.code, sizeof(security_code.code));
gn_data_clear(data);
data->security_code = &security_code;
error = gn_sm_functions(GN_OP_EnterSecurityCode, data, state);
switch (error) {
case GN_ERR_NONE:
fprintf(stderr, _("Code ok.\n"));
break;
default:
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
break;
}
return error;
}
/* Reads profile from phone and displays its' settings */
gn_error getprofile(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
int max_profiles;
int start, stop, i;
gn_profile p;
gn_ringtone_list rl;
gn_error error = GN_ERR_NOTSUPPORTED;
/* Hopefully is 64 larger as FB38_MAX* / FB61_MAX* */
char model[64] = "";
bool raw = false;
struct option options[] = {
{ "raw", no_argument, NULL, 'r'},
{ NULL, 0, NULL, 0}
};
while ((i = getopt_long(argc, argv, "r", options, NULL)) != -1) {
switch (i) {
case 'r':
raw = true;
break;
default:
return getprofile_usage(stderr, -1); /* FIXME */
}
}
gn_data_clear(data);
data->model = model;
while (gn_sm_functions(GN_OP_GetModel, data, state) != GN_ERR_NONE)
sleep(1);
p.number = 0;
memset(&rl, 0, sizeof(gn_ringtone_list));
gn_data_clear(data);
data->profile = &p;
data->ringtone_list = &rl;
error = gn_sm_functions(GN_OP_GetProfile, data, state);
switch (error) {
case GN_ERR_NONE:
break;
default:
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
return error;
}
max_profiles = 7; /* This is correct for 6110 (at least my). How do we get
the number of profiles? */
/* For N5110 */
/* FIXME: It should be set to 3 for N5130 and 3210 too */
if (!strcmp(model, "NSE-1"))
max_profiles = 3;
if (argc > optind) {
start = gnokii_atoi(argv[optind]);
if (errno || start < 0)
return getprofile_usage(stderr, -1);
stop = (argc > optind + 1) ? gnokii_atoi(argv[optind + 1]) : start;
if (errno || stop < 0)
return getprofile_usage(stderr, -1);
if (start > stop) {
fprintf(stderr, _("Starting profile number is greater than stop\n"));
return GN_ERR_FAILED;
}
if (start < 0) {
fprintf(stderr, _("Profile number must be value from 0 to %d!\n"), max_profiles - 1);
return GN_ERR_FAILED;
}
if (stop >= max_profiles) {
fprintf(stderr, _("This phone supports only %d profiles!\n"), max_profiles);
return GN_ERR_FAILED;
}
} else {
start = 0;
stop = max_profiles - 1;
}
gn_data_clear(data);
data->profile = &p;
data->ringtone_list = &rl;
for (i = start; i <= stop; i++) {
p.number = i;
if (p.number != 0) {
error = gn_sm_functions(GN_OP_GetProfile, data, state);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Cannot get profile %d\n"), i);
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
return error;
}
}
if (raw) {
fprintf(stdout, "%d;%s;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d\n",
p.number, p.name, p.default_name, p.keypad_tone,
p.lights, p.call_alert, p.ringtone, p.volume,
p.message_tone, p.vibration, p.warning_tone,
p.caller_groups, p.automatic_answer);
} else {
/* Translators: %d is the profile number, %s is the profile name. Example: 1. "Outdoors" */
fprintf(stdout, _("%d. \"%s\"\n"), p.number, p.name);
if (p.default_name == -1) fprintf(stdout, _(" (name defined)\n"));
fprintf(stdout, _("Incoming call alert: %s\n"), gn_profile_callalert_type2str(p.call_alert));
fprintf(stdout, _("Ringing tone: %s (%d)\n"), get_ringtone_name(p.ringtone, data, state), p.ringtone);
fprintf(stdout, _("Ringing volume: %s\n"), gn_profile_volume_type2str(p.volume));
fprintf(stdout, _("Message alert tone: %s\n"), gn_profile_message_type2str(p.message_tone));
fprintf(stdout, _("Keypad tones: %s\n"), gn_profile_keyvol_type2str(p.keypad_tone));
fprintf(stdout, _("Warning and game tones: %s\n"), gn_profile_warning_type2str(p.warning_tone));
/* FIXME: Light settings is only used for Car */
if (p.number == (max_profiles - 2)) fprintf(stdout, _("Lights: %s\n"), p.lights ? _("On") : _("Automatic"));
fprintf(stdout, _("Vibration: %s\n"), gn_profile_vibration_type2str(p.vibration));
/* FIXME: it will be nice to add here reading caller group name. */
if (max_profiles != 3) fprintf(stdout, _("Caller groups: 0x%02x\n"), p.caller_groups);
/* FIXME: Automatic answer is only used for Car and Headset. */
if (p.number >= (max_profiles - 2)) fprintf(stdout, _("Automatic answer: %s\n"), p.automatic_answer ? _("On") : _("Off"));
fprintf(stdout, "\n");
}
}
return error;
}
gn_error playringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_ringtone ringtone;
gn_tone tone;
gn_error error;
char *filename = optarg;
int i, ulen;
struct timeval dt;
#if (defined HAVE_TIMEOPS) && (defined HAVE_GETTIMEOFDAY)
struct timeval t1, t2;
#endif
int volume = 5;
struct option options[] = {
{ "volume", required_argument, NULL, 'v'},
{ NULL, 0, NULL, 0}
};
while ((i = getopt_long(argc, argv, "v:", options, NULL)) != -1) {
switch (i) {
case 'v':
volume = gnokii_atoi(optarg);
if (errno || volume < 0)
return playringtone_usage(stderr, -1);
break;
default:
return playringtone_usage(stderr, -1);
}
}
if (argc > optind) {
/* There are too many arguments that don't start with '-' */
return playringtone_usage(stderr, -1);
}
memset(&ringtone, 0, sizeof(ringtone));
memset(&tone, 0, sizeof(tone));
gn_data_clear(data);
data->ringtone = &ringtone;
data->tone = &tone;
if (!filename) {
fprintf(stderr, _("Internal gnokii error: null filename\n"));
return GN_ERR_FAILED;
}
if ((error = gn_file_ringtone_read(filename, &ringtone))) {
fprintf(stderr, _("Failed to load ringtone: %s\n"), gn_error_print(error));
return error;
}
#if (defined HAVE_TIMEOPS) && (defined HAVE_GETTIMEOFDAY)
gettimeofday(&t1, NULL);
tone.frequency = 0;
tone.volume = 0;
gn_sm_functions(GN_OP_PlayTone, data, state);
gettimeofday(&t2, NULL);
timersub(&t2, &t1, &dt);
#else
dt.tv_sec = 0;
dt.tv_usec = 20000;
#endif
signal(SIGINT, interrupted);
for (i = 0; !bshutdown && i < ringtone.notes_count; i++) {
tone.volume = volume;
gn_ringtone_get_tone(&ringtone, i, &tone.frequency, &ulen);
if ((error = gn_sm_functions(GN_OP_PlayTone, data, state)) != GN_ERR_NONE) break;
if (ulen > 2 * dt.tv_usec + 20000)
usleep(ulen - 2 * dt.tv_usec - 20000);
tone.volume = 0;
if ((error = gn_sm_functions(GN_OP_PlayTone, data, state)) != GN_ERR_NONE) break;
usleep(20000);
}
tone.frequency = 0;
tone.volume = 0;
gn_sm_functions(GN_OP_PlayTone, data, state);
if (error == GN_ERR_NONE)
fprintf(stderr, _("Play succeeded!\n"));
else
fprintf(stderr, _("Play failed: %s\n"), gn_error_print(error));
return error;
}
gn_error setringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_ringtone ringtone;
gn_raw_data rawdata;
gn_error error;
unsigned char buff[512];
char *filename = optarg;
int i, location;
bool raw = false;
char name[16] = "";
struct option options[] = {
{ "raw", no_argument, NULL, 'r'},
{ "name", required_argument, NULL, 'n'},
{ NULL, 0, NULL, 0}
};
while ((i = getopt_long(argc, argv, "rn:", options, NULL)) != -1) {
switch (i) {
case 'r':
raw = true;
break;
case 'n':
snprintf(name, sizeof(name), "%s", optarg);
break;
default:
return setringtone_usage(stderr, -1);
}
}
if (argc - optind > 2) {
/* There are too many arguments that don't start with '-' */
return setringtone_usage(stderr, -1);
}
memset(&ringtone, 0, sizeof(ringtone));
rawdata.data = buff;
rawdata.length = sizeof(buff);
gn_data_clear(data);
data->ringtone = &ringtone;
data->raw_data = &rawdata;
errno = 0;
location = (argc > optind + 1) ? gnokii_atoi(argv[optind + 1]) : -1;
if (errno)
return setringtone_usage(stderr, -1);
if (!filename) {
fprintf(stderr, _("Internal gnokii error: null filename\n"));
return GN_ERR_FAILED;
}
if (raw) {
FILE *f;
if ((f = fopen(filename, "rb")) == NULL) {
fprintf(stderr, _("Failed to load ringtone.\n"));
return GN_ERR_FAILED;
}
rawdata.length = fread(rawdata.data, 1, rawdata.length, f);
fclose(f);
ringtone.location = location;
if (*name)
snprintf(ringtone.name, sizeof(ringtone.name), "%s", name);
else
snprintf(ringtone.name, sizeof(ringtone.name), "GNOKII");
error = gn_sm_functions(GN_OP_SetRawRingtone, data, state);
} else {
if ((error = gn_file_ringtone_read(filename, &ringtone))) {
fprintf(stderr, _("Failed to load ringtone.\n"));
return error;
}
ringtone.location = location;
if (*name) snprintf(ringtone.name, sizeof(ringtone.name), "%s", name);
error = gn_sm_functions(GN_OP_SetRingtone, data, state);
}
if (error == GN_ERR_NONE)
fprintf(stderr, _("Send succeeded!\n"));
else
fprintf(stderr, _("Send failed: %s\n"), gn_error_print(error));
return error;
}
gn_error getringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_ringtone ringtone;
gn_raw_data rawdata;
gn_error error;
unsigned char buff[512];
char *filename = optarg;
int i;
bool raw = false;
struct option options[] = {
{ "raw", no_argument, NULL, 'r'},
{ NULL, 0, NULL, 0}
};
memset(&ringtone, 0, sizeof(ringtone));
rawdata.data = buff;
rawdata.length = sizeof(buff);
gn_data_clear(data);
data->ringtone = &ringtone;
data->raw_data = &rawdata;
while ((i = getopt_long(argc, argv, "r", options, NULL)) != -1) {
switch (i) {
case 'r':
raw = true;
break;
default:
return getringtone_usage(stderr, -1);
}
}
if (argc == optind) {
/* There are 0 arguments that don't start with '-' */
init_ringtone_list(data, state);
ringtone.location = ringtone_list.userdef_location;
} else if (argc - optind == 1) {
/* There is 1 argument that doesn't start with '-' */
ringtone.location = gnokii_atoi(argv[optind]);
if (errno || ringtone.location < 0)
return getringtone_usage(stderr, -1);
} else {
/* There are too many arguments that don't start with '-' */
return getringtone_usage(stderr, -1);
}
if (raw)
error = gn_sm_functions(GN_OP_GetRawRingtone, data, state);
else
error = gn_sm_functions(GN_OP_GetRingtone, data, state);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Getting ringtone %d failed: %s\n"), ringtone.location, gn_error_print(error));
goto out;
}
fprintf(stderr, _("Getting ringtone %d (\"%s\") succeeded!\n"), ringtone.location, ringtone.name);
if (!filename) {
fprintf(stderr, _("Internal gnokii error: null filename\n"));
error = GN_ERR_FAILED;
goto out;
}
if (raw) {
FILE *f;
if ((f = fopen(filename, "wb")) == NULL) {
fprintf(stderr, _("Failed to save ringtone.\n"));
error = -1;
goto out;
}
if (fwrite(rawdata.data, rawdata.length, 1, f) < 1) {
fprintf(stderr, _("Failed to write ringtone.\n"));
error = -1;
}
fclose(f);
} else {
if ((error = gn_file_ringtone_save(filename, &ringtone)) != GN_ERR_NONE) {
fprintf(stderr, _("Failed to save ringtone: %s\n"), gn_error_print(error));
/* return */
}
}
out:
return error;
}
gboolean libgnokii_sms_send_api(pegang *unit)
{
if(!holdgnokii_init)
{
printf("hold_gnokii_init aint initialized\n");
return FALSE;
}
//avoiding
if(unit->sms_send_encapsulation->no_dest == NULL || strlen(unit->sms_send_encapsulation->no_dest) < 2 || unit->sms_send_encapsulation->msg == NULL || strlen(unit->sms_send_encapsulation->msg) < 2)
{
return FALSE;
}
gn_sms sms;
gn_error error;
gn_data data;
int pos = 0;
//memset to zero
gn_sms_default_submit(&sms);
gn_data_clear(&data);
//set the dest number
snprintf(sms.remote.number,sizeof(sms.remote.number),"%s",unit->sms_send_encapsulation->no_dest);
sms.remote.type = libgnokii_nomorhp_tipe_api(unit->sms_send_encapsulation->no_dest);
if(sms.remote.type == GN_GSM_NUMBER_Alphanumeric)
{
printf("Invalid Phone Number\n");
return FALSE;
}
//set txt to be sent and length of it
error = libgnokii_bacatext_api(&sms.user_data[pos],unit);
sms.user_data[pos].type = GN_SMS_DATA_Text;
/*
if ((sms.dcs.u.general.alphabet != GN_SMS_DCS_8bit) && !gn_char_def_alphabet(sms.user_data[pos].u.text))
sms.dcs.u.general.alphabet = GN_SMS_DCS_UCS2;
sms.user_data[++pos].type = GN_SMS_DATA_None;
*/
//report the delivery
sms.delivery_report = 1;
//auto get sms center
data.message_center = calloc(1, sizeof(gn_sms_message_center)); //allocate only for one element of data->message_center and size of its element is sizeof(gn_sms_message_center)
data.message_center->id = 1;
error = gn_sm_functions(GN_OP_GetSMSCenter, &data, state);
if(error == GN_ERR_NONE)
{
snprintf(sms.smsc.number,sizeof(sms.smsc.number),"%s",data.message_center->smsc.number); // set to sms.smsc.number from data.sms.smsc.number
sms.smsc.type = data.message_center->smsc.type;
//g_slice_free(gn_sms_message_center,data->message_center); // free the ram
free(data.message_center);
}
if(!sms.smsc.number[0])
{
printf("failed once getting sms center number\n");
return FALSE;
}
if(!sms.smsc.type)
{
sms.smsc.type = GN_GSM_NUMBER_Unknown;
}
//now give the data.sms from what all we have in sms, and make sure before these data.sms has been freed...
data.sms = &sms;
//send the message
error = gn_sms_send(&data,state);
if(error == GN_ERR_NONE)
{
if(sms.parts > 1)
{
int j;
printf("sms sent with : %d parts, and reference number is : ", sms.parts);
for(j=0; j < sms.parts; j++)
{
printf("%d\n",sms.reference[j]);
}
}
else
{
printf("one sms sent with reference number : %d\n",sms.reference[0]);
}
}
else
{
printf("libgnokii error : %s\n",gn_error_print(error));
return FALSE;
}
free(sms.reference);
return TRUE;
}
int main(int argc, char *argv[])
{
const char *aux;
static bool atexit_registered = false;
struct gn_statemachine temp_state;
/* For GNU gettext */
#ifdef ENABLE_NLS
setlocale(LC_ALL, "");
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
#endif
short_version();
/* Handle command line arguments. */
switch (argc) {
case 1:
/* Default */
DebugMode = false;
break;
case 2:
if (strcmp(argv[1], "--version") == 0) {
/* Display version, copyright and build information. */
version();
exit(0);
} else if (strcmp(argv[1], "--debug") == 0) {
/* Use stdin/stdout for I/O */
DebugMode = true;
break;
} else if (strcmp(argv[1], "--help") == 0) {
usage();
exit(0);
}
/* FALL TROUGH */
default:
usage();
exit(1);
}
aux = gn_lib_cfg_get("global", "model");
if (!aux) {
fprintf(stderr, "%s\n", gn_error_print(GN_ERR_NOCONFIG));
exit(1);
}
if (strncmp(aux, "5110", 4) &&
strncmp(aux, "5130", 4) &&
strncmp(aux, "6110", 4) &&
strncmp(aux, "6130", 4) &&
strncmp(aux, "6150", 4)) {
fprintf(stderr, _("gnokiid purpose is to work only with the phones that do not have AT Hayes\ncommands interpreter.\n"));
exit(1);
}
BinDir = gn_lib_cfg_get("global", "bindir");
if (!BinDir) BinDir = gn_lib_cfg_get("gnokiid", "bindir");
if (!BinDir) BinDir = SBINDIR;
if (gn_cfg_phone_load("", &temp_state) != GN_ERR_NONE) exit(-1);
gn_elog_handler = NULL;
if (temp_state.config.use_locking) {
lockfile = gn_device_lock(temp_state.config.port_device);
if (lockfile == NULL) {
fprintf(stderr, _("Lock file error. Exiting.\n"));
exit(1);
}
}
/* register cleanup function */
if (!atexit_registered) {
atexit_registered = true;
atexit(busterminate);
}
while (1) {
if (gn_vm_initialise("", BinDir, DebugMode, true) == false) {
exit (-1);
}
GTerminateThread = false;
gn_vm_loop();
}
exit (0);
}
/* ToDo notes receiving. */
gn_error gettodo(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_todo_list todolist;
gn_todo todo;
gn_error error = GN_ERR_NONE;
bool vcal = false;
int i, first_location, last_location;
struct option options[] = {
{ "vCal", optional_argument, NULL, 'v'},
{ NULL, 0, NULL, 0}
};
first_location = gnokii_atoi(optarg);
if (errno || first_location < 0)
return gettodo_usage(stderr, -1);
last_location = parse_end_value_option(argc, argv, optind, first_location);
if (errno || last_location < 0)
return gettodo_usage(stderr, -1);
while ((i = getopt_long(argc, argv, "v", options, NULL)) != -1) {
switch (i) {
case 'v':
vcal = true;
break;
default:
return gettodo_usage(stderr, -1);
}
}
for (i = first_location; i <= last_location; i++) {
todo.location = i;
gn_data_clear(data);
data->todo = &todo;
data->todo_list = &todolist;
error = gn_sm_functions(GN_OP_GetToDo, data, state);
switch (error) {
case GN_ERR_NONE:
if (vcal) {
gn_todo2ical(stdout, &todo);
} else {
fprintf(stdout, _("%s: %s\n"), _("Todo"), todo.text);
fprintf(stdout, _("%s: %s\n"), _("Priority"), gn_todo_priority2str(todo.priority));
}
break;
default:
/* stop processing if the last note was specified as "end" */
if (last_location == INT_MAX) {
/* it's not an error if we read at least a note and the rest is empty */
if ((i > first_location) && ((error == GN_ERR_EMPTYLOCATION) || (error == GN_ERR_INVALIDLOCATION))) {
error = GN_ERR_NONE;
}
last_location = 0;
}
if (error != GN_ERR_NONE) {
fprintf(stderr, _("The ToDo note could not be read: %s\n"), gn_error_print(error));
}
}
}
return error;
}
/* Delete MMS messages. */
gn_error deletemms(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_mms message;
char *memory_type_string;
int start_message, end_message, count;
gn_error error = GN_ERR_NONE;
/* Handle command line args that set type, start and end locations. */
memory_type_string = optarg;
message.memory_type = gn_str2memory_type(memory_type_string);
if (message.memory_type == GN_MT_XX) {
fprintf(stderr, _("Unknown memory type %s (use ME, SM, IN, OU, ...)!\n"), optarg);
fprintf(stderr, _("Run gnokii --showsmsfolderstatus for a list of supported memory types.\n"));
return GN_ERR_INVALIDMEMORYTYPE;
}
start_message = gnokii_atoi(argv[optind]);
if (errno || start_message < 0)
return deletemms_usage(stderr, -1);
end_message = parse_end_value_option(argc, argv, optind + 1, start_message);
if (errno || end_message < 0)
return deletemms_usage(stderr, -1);
/* Now delete the requested entries. */
for (count = start_message; count <= end_message; count++) {
message.number = count;
data->mms = &message;
error = gn_mms_delete(data, state);
if (error == GN_ERR_NONE)
fprintf(stderr, _("Deleted MMS (location %d from memory %s)\n"), count, memory_type_string);
else {
if ((error == GN_ERR_INVALIDLOCATION) && (end_message == INT_MAX) && (count > start_message))
return GN_ERR_NONE;
fprintf(stderr, _("Deleting MMS failed (location %d from memory %s)! (%s)\n"), count, memory_type_string, gn_error_print(error));
}
}
/* FIXME: We return the value of the last read.
* What should we return?
*/
return error;
}
/* ToDo notes writing */
gn_error writetodo(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_todo todo;
gn_error error = GN_ERR_NONE;
int first_location, last_location, i;
FILE *f;
f = fopen(optarg, "r");
if (f == NULL) {
fprintf(stderr, _("Can't open file %s for reading!\n"), optarg);
return GN_ERR_FAILED;
}
first_location = gnokii_atoi(argv[optind]);
if (errno || first_location < 0) {
fclose(f);
return writetodo_usage(stderr, -1);
}
last_location = parse_end_value_option(argc, argv, optind + 1, first_location);
if (errno || last_location < 0) {
fclose(f);
return writetodo_usage(stderr, -1);
}
for (i = first_location; i <= last_location; i++) {
memset(&todo, 0, sizeof(todo));
gn_data_clear(data);
data->todo = &todo;
/* TODO: gn_ical2todo expects the pointer to begin file to
* iterate. Fix it to not rewind the file each time
*/
rewind(f);
error = gn_ical2todo(f, &todo, i);
#ifndef WIN32
if (error == GN_ERR_NOTIMPLEMENTED) {
switch (gn_vcal_file_todo_read(optarg, &todo, i)) {
case 0:
error = GN_ERR_NONE;
break;
default:
error = GN_ERR_FAILED;
break;
}
}
#endif
if (error != GN_ERR_NONE) {
/* when reading until 'end' it's not an error if it tried to read a non existant note */
if ((last_location == INT_MAX) && (error == GN_ERR_EMPTYLOCATION)) {
error = GN_ERR_NONE;
} else {
fprintf(stderr, _("Failed to load vCalendar file: %s\n"), gn_error_print(error));
}
fclose(f);
return error;
}
error = gn_sm_functions(GN_OP_WriteToDo, data, state);
if (error == GN_ERR_NONE) {
fprintf(stderr, _("Successfully written!\n"));
fprintf(stderr, _("Priority %d. %s\n"), data->todo->priority, data->todo->text);
} else
fprintf(stderr, _("Failed to write ToDo note: %s\n"), gn_error_print(error));
}
fclose(f);
return error;
}
/* Get MMS messages. */
gn_error getmms(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
int i, del = 0;
gn_sms_folder folder;
gn_sms_folder_list folderlist;
gn_mms *message;
char *memory_type_string;
int start_message, end_message, count;
gnokii_app_mode mode = GNOKII_APP_MODE_Ask;
char filename[64];
gn_error error = GN_ERR_NONE;
gn_mms_format output_format_type = GN_MMS_FORMAT_TEXT;
struct option options[] = {
{ "mime", required_argument, NULL, GN_MMS_FORMAT_MIME},
{ "pdu", required_argument, NULL, GN_MMS_FORMAT_PDU},
{ "raw", required_argument, NULL, GN_MMS_FORMAT_RAW},
{ "delete", no_argument, NULL, 'd' },
{ "overwrite", no_argument, NULL, 'o' },
{ NULL, 0, NULL, 0 }
};
/* Handle command line args that set type, start and end locations. */
memory_type_string = optarg;
if (gn_str2memory_type(memory_type_string) == GN_MT_XX) {
fprintf(stderr, _("Unknown memory type %s (use ME, SM, IN, OU, ...)!\n"), optarg);
fprintf(stderr, _("Run gnokii --showsmsfolderstatus for a list of supported memory types.\n"));
return GN_ERR_INVALIDMEMORYTYPE;
}
start_message = gnokii_atoi(argv[optind]);
if (errno || start_message < 0)
return getmms_usage(stderr, -1);
end_message = parse_end_value_option(argc, argv, optind + 1, start_message);
if (errno || end_message < 0)
return getmms_usage(stderr, -1);
*filename = '\0';
/* parse all options (beginning with '-') */
while ((i = getopt_long(argc, argv, "1:2:3:do", options, NULL)) != -1) {
switch (i) {
case 'd':
del = 1;
break;
/* force mode -- don't ask to overwrite */
case 'o':
mode = GNOKII_APP_MODE_Overwrite;
break;
case GN_MMS_FORMAT_MIME:
/* FALL THROUGH */
case GN_MMS_FORMAT_PDU:
/* FALL THROUGH */
case GN_MMS_FORMAT_RAW:
/* output formats are mutually exclusive */
if (output_format_type != GN_MMS_FORMAT_TEXT) {
return getmms_usage(stderr, -1);
}
output_format_type = i;
if (!optarg) {
return getsms_usage(stderr, -1);
}
snprintf(filename, sizeof(filename), "%s", optarg);
fprintf(stderr, _("Saving into %s\n"), filename);
break;
default:
return getmms_usage(stderr, -1);
}
}
if (argc - optind > 3) {
/* There are too many arguments that don't start with '-' */
return getmms_usage(stderr, -1);
}
folder.folder_id = 0;
data->sms_folder = &folder;
data->sms_folder_list = &folderlist;
/* Now retrieve the requested entries. */
for (count = start_message; count <= end_message; count++) {
error = gn_mms_alloc(&message);
if (error != GN_ERR_NONE)
break;
message->memory_type = gn_str2memory_type(memory_type_string);
message->number = count;
message->buffer_format = output_format_type;
data->mms = message;
error = gn_mms_get(data, state);
switch (error) {
case GN_ERR_NONE:
if (*filename) {
/* writebuffer() will set mode to "append" */
mode = writebuffer(filename, data->mms->buffer, data->mms->buffer_length, mode);
} else {
error = fprint_mms(stdout, message);
fprintf(stdout, "\n");
}
if (del && mode != GNOKII_APP_MODE_Cancel) {
if (GN_ERR_NONE != gn_mms_delete(data, state))
fprintf(stderr, _("(delete failed)\n"));
else
fprintf(stderr, _("(message deleted)\n"));
}
break;
default:
if ((error == GN_ERR_INVALIDLOCATION) && (end_message == INT_MAX) && (count > start_message)) {
error = GN_ERR_NONE;
/* Force exit */
mode = GNOKII_APP_MODE_Cancel;
break;
}
fprintf(stderr, _("Getting MMS failed (location %d from memory %s)! (%s)\n"), count, memory_type_string, gn_error_print(error));
if (error == GN_ERR_INVALIDMEMORYTYPE) {
fprintf(stderr, _("Unknown memory type %s (use ME, SM, IN, OU, ...)!\n"), optarg);
fprintf(stderr, _("Run gnokii --showsmsfolderstatus for a list of supported memory types.\n"));
}
if (error == GN_ERR_EMPTYLOCATION)
error = GN_ERR_NONE;
break;
}
gn_mms_free(message);
if (mode == GNOKII_APP_MODE_Cancel)
break;
}
return error;
}
static QString businit(void)
{
gn_error error;
char *aux;
if (gn_cfg_read(&BinDir)<0 || !gn_cfg_phone_load("", &state))
return i18n("GNOKII isn't yet configured.");
gn_data_clear(&data);
aux = gn_cfg_get(gn_cfg_info, "global", "use_locking");
// Defaults to 'no'
if (aux && !strcmp(aux, "yes")) {
lockfile = gn_device_lock(state.config.port_device);
if (lockfile == NULL) {
return i18n("Lock file error.\n "
"Please exit all other running instances of gnokii and try again.");
}
}
// Initialise the code for the GSM interface.
int old_dcd = state.config.require_dcd; // work-around for older gnokii versions
state.config.require_dcd = false;
error = gn_gsm_initialise(&state);
GNOKII_CHECK_ERROR(error);
state.config.require_dcd = old_dcd;
if (error != GN_ERR_NONE) {
busterminate();
return i18n("Mobile phone interface initialization failed:\n%1").arg(gn_error_print(error));
}
// model
gn_data_clear(&data);
data.model = model;
model[0] = 0;
error = gn_sm_functions(GN_OP_GetModel, &data, &state);
GNOKII_CHECK_ERROR(error);
if (model[0] == 0)
strcpy(model, i18n("unknown").utf8());
data.model = NULL;
// revision
data.revision = revision;
revision[0] = 0;
error = gn_sm_functions(GN_OP_GetRevision, &data, &state);
GNOKII_CHECK_ERROR(error);
data.revision = NULL;
// imei
data.imei = imei;
imei[0] = 0;
error = gn_sm_functions(GN_OP_GetImei, &data, &state);
GNOKII_CHECK_ERROR(error);
data.imei = NULL;
GNOKII_DEBUG( QString("Found mobile phone: Model: %1, Revision: %2, IMEI: %3\n")
.arg(model).arg(revision).arg(imei) );
PhoneProductId = QString("%1-%2-%3-%4").arg(APP).arg(model).arg(revision).arg(imei);
return QString::null;
}
