/*
* Print NTP time requests and responses
*/
static void
ntp_time_print(netdissect_options *ndo,
const struct ntp_time_data *bp, u_int length)
{
uint8_t stratum;
if (length < NTP_TIMEMSG_MINLEN)
goto invalid;
ND_TCHECK_1(bp->stratum);
stratum = EXTRACT_U_1(bp->stratum);
ND_PRINT(", Stratum %u (%s)",
stratum,
tok2str(ntp_stratum_values, (stratum >=2 && stratum<=15) ? "secondary reference" : "reserved", stratum));
ND_TCHECK_1(bp->ppoll);
ND_PRINT(", poll %d", EXTRACT_S_1(bp->ppoll));
p_poll(ndo, EXTRACT_S_1(bp->ppoll));
ND_TCHECK_1(bp->precision);
ND_PRINT(", precision %d", EXTRACT_S_1(bp->precision));
ND_TCHECK_SIZE(&bp->root_delay);
ND_PRINT("\n\tRoot Delay: ");
p_sfix(ndo, &bp->root_delay);
ND_TCHECK_SIZE(&bp->root_dispersion);
ND_PRINT(", Root dispersion: ");
p_sfix(ndo, &bp->root_dispersion);
ND_TCHECK_4(bp->refid);
ND_PRINT(", Reference-ID: ");
/* Interpretation depends on stratum */
switch (stratum) {
case UNSPECIFIED:
ND_PRINT("(unspec)");
break;
case PRIM_REF:
if (nd_printn(ndo, (const u_char *)&(bp->refid), 4, ndo->ndo_snapend))
goto trunc;
break;
case INFO_QUERY:
ND_PRINT("%s INFO_QUERY", ipaddr_string(ndo, bp->refid));
/* this doesn't have more content */
return;
case INFO_REPLY:
ND_PRINT("%s INFO_REPLY", ipaddr_string(ndo, bp->refid));
/* this is too complex to be worth printing */
return;
default:
/* In NTPv4 (RFC 5905) refid is an IPv4 address or first 32 bits of
MD5 sum of IPv6 address */
ND_PRINT("0x%08x", EXTRACT_BE_U_4(bp->refid));
break;
}
ND_TCHECK_SIZE(&bp->ref_timestamp);
ND_PRINT("\n\t Reference Timestamp: ");
p_ntp_time(ndo, &(bp->ref_timestamp));
ND_TCHECK_SIZE(&bp->org_timestamp);
ND_PRINT("\n\t Originator Timestamp: ");
p_ntp_time(ndo, &(bp->org_timestamp));
ND_TCHECK_SIZE(&bp->rec_timestamp);
ND_PRINT("\n\t Receive Timestamp: ");
p_ntp_time(ndo, &(bp->rec_timestamp));
ND_TCHECK_SIZE(&bp->xmt_timestamp);
ND_PRINT("\n\t Transmit Timestamp: ");
p_ntp_time(ndo, &(bp->xmt_timestamp));
ND_PRINT("\n\t Originator - Receive Timestamp: ");
p_ntp_delta(ndo, &(bp->org_timestamp), &(bp->rec_timestamp));
ND_PRINT("\n\t Originator - Transmit Timestamp: ");
p_ntp_delta(ndo, &(bp->org_timestamp), &(bp->xmt_timestamp));
/* FIXME: this code is not aware of any extension fields */
if (length == NTP_TIMEMSG_MINLEN + 4) { /* Optional: key-id (crypto-NAK) */
ND_TCHECK_4(bp->key_id);
ND_PRINT("\n\tKey id: %u", EXTRACT_BE_U_4(bp->key_id));
} else if (length == NTP_TIMEMSG_MINLEN + 4 + 16) { /* Optional: key-id + 128-bit digest */
ND_TCHECK_4(bp->key_id);
ND_PRINT("\n\tKey id: %u", EXTRACT_BE_U_4(bp->key_id));
ND_TCHECK_LEN(bp->message_digest, 16);
ND_PRINT("\n\tAuthentication: %08x%08x%08x%08x",
EXTRACT_BE_U_4(bp->message_digest),
EXTRACT_BE_U_4(bp->message_digest + 4),
EXTRACT_BE_U_4(bp->message_digest + 8),
EXTRACT_BE_U_4(bp->message_digest + 12));
} else if (length == NTP_TIMEMSG_MINLEN + 4 + 20) { /* Optional: key-id + 160-bit digest */
ND_TCHECK_4(bp->key_id);
ND_PRINT("\n\tKey id: %u", EXTRACT_BE_U_4(bp->key_id));
ND_TCHECK_LEN(bp->message_digest, 20);
ND_PRINT("\n\tAuthentication: %08x%08x%08x%08x%08x",
EXTRACT_BE_U_4(bp->message_digest),
EXTRACT_BE_U_4(bp->message_digest + 4),
EXTRACT_BE_U_4(bp->message_digest + 8),
EXTRACT_BE_U_4(bp->message_digest + 12),
EXTRACT_BE_U_4(bp->message_digest + 16));
} else if (length > NTP_TIMEMSG_MINLEN) {
ND_PRINT("\n\t(%u more bytes after the header)", length - NTP_TIMEMSG_MINLEN);
}
return;
invalid:
nd_print_invalid(ndo);
ND_TCHECK_LEN(bp, length);
return;
trunc:
nd_print_trunc(ndo);
}
gint32
gap_xanim_decode(GimpRunModeType run_mode)
{
gint32 l_rc;
gint32 first_frame;
gint32 last_frame;
char filename[200];
char basename[200];
char extension[20];
char extension2[20];
t_gap_xa_formats Format;
gint32 extract_audio;
gint32 extract_video;
gint32 jpeg_quality;
gint32 autoload;
gint32 run_xanim_asynchron;
char l_cmd[300];
char l_one_past_last_frame[200];
char l_first_to_laod[200];
char *l_dst_dir;
pid_t l_xanim_pid;
int l_input_dir_created_by_myself;
l_rc = 0;
l_input_dir_created_by_myself = FALSE;
global_errlist = NULL;
p_init_xanim_global_name();
filename[0] = '\0';
strcpy(&basename[0], "frame_");
l_rc = p_xanim_dialog (&first_frame,
&last_frame,
filename, sizeof(filename),
basename, sizeof(basename),
&Format,
&extract_video,
&extract_audio,
&jpeg_quality,
&autoload,
&run_xanim_asynchron);
if(l_rc != 0)
{
return(l_rc);
}
if(!p_file_exists(filename))
{
global_errlist = g_strdup_printf(
_("videofile %s not existent or empty\n"),
filename);
l_rc = 10;
}
else
{
l_rc = p_check_xanim();
}
if (l_rc == 0)
{
switch(Format)
{
case XAENC_PPMRAW:
strcpy(extension, "ppm");
strcpy(extension2, ".ppm");
break;
case XAENC_JPEG:
strcpy(extension, "jpg");
strcpy(extension2, ".jpg");
break;
default:
strcpy(extension, "ppm");
strcpy(extension2, ".xcf");
break;
}
p_build_xanim_framename(l_one_past_last_frame, last_frame +1 , extension);
if (extract_video)
{
/* for the frames we need a directory named "input" */
if (p_is_directory(global_xanim_input_dir))
{
/* the input directory already exists,
* remove frames
*/
sprintf(l_cmd, "rm -f %s/*.%s", global_xanim_input_dir, extension);
system(l_cmd);
}
else
{
/* create input directory (needed by xanim to store the frames) */
mkdir(global_xanim_input_dir, MKDIR_MODE);
if (p_is_directory(global_xanim_input_dir))
{
l_input_dir_created_by_myself = TRUE;
}
else
{
global_errlist = g_strdup_printf(
_("could not create %s directory\n"
"(that is required for xanim frame export)"),
global_xanim_input_dir);
l_rc = 10;
}
}
}
}
if(l_rc == 0)
{
gimp_progress_init (_("extracting frames..."));
gimp_progress_update (0.1); /* fake some progress */
/* note:
* we can't show realistic progress for the extracting process
* because we know nothing about videofileformat and how much frames
* are realy stored in the videofile.
*
* one guess could assume, that xanim will write 0 upto last_frame
* to disk, and check for the frames that the xanim process creates.
* The periodically checking can be done in the poll procedure for asynchron
* startmode only.
*/
l_xanim_pid = p_start_xanim_process(first_frame, last_frame,
filename,
Format,
extract_video,
extract_audio,
jpeg_quality,
l_one_past_last_frame,
run_xanim_asynchron);
if (l_xanim_pid == -1 )
{
global_errlist = g_strdup_printf(
_("could not start xanim process\n(program=%s)"),
global_xanim_prog );
l_rc = -1;
}
}
if(l_rc == 0)
{
if(run_xanim_asynchron)
{
p_poll(l_xanim_pid, l_one_past_last_frame, first_frame, last_frame, extension);
}
p_delete_frames(99999, first_frame, last_frame, extension);
remove(l_one_past_last_frame);
gimp_progress_update (1.0);
if (p_find_max_xanim_frame (first_frame, extension) < first_frame)
{
global_errlist = g_strdup_printf(
_("can't find any extracted frames,\n"
"xanim has failed or was cancelled"));
l_rc = -1;
}
else
{
/* if destination directorypart does not exist, try to create it */
l_dst_dir = g_strdup(basename);
p_dirname(l_dst_dir);
if (*l_dst_dir != '\0')
{
if ( !p_is_directory(l_dst_dir) )
{
mkdir (l_dst_dir, MKDIR_MODE);
}
}
if(strcmp(extension, &extension2[1]) == 0)
{
gimp_progress_init (_("renaming frames..."));
l_rc = p_rename_frames(first_frame, last_frame, basename, extension);
}
else
{
gimp_progress_init (_("converting frames..."));
l_rc = p_convert_frames(first_frame, last_frame, basename, extension, extension2);
}
if (l_input_dir_created_by_myself)
{
if (strcmp(l_dst_dir, global_xanim_input_dir) != 0)
{
/* remove input dir with all files */
sprintf(l_cmd, "rm -rf \"%s\"", global_xanim_input_dir);
system(l_cmd);
}
}
g_free(l_dst_dir);
gimp_progress_update (1.0);
}
}
if(l_rc != 0)
{
if(global_errlist == NULL)
{
p_xanim_info("ERROR: could not execute xanim");
}
else
{
p_xanim_info(global_errlist);
}
l_rc = -1;
}
else
{
if(autoload)
{
/* load first frame and add a display */
p_build_gap_framename(l_first_to_laod, first_frame, basename, &extension2[1]);
l_rc = p_load_image(l_first_to_laod);
if(l_rc >= 0) gimp_display_new(l_rc);
}
}
return(l_rc);
} /* end gap_xanim_decode */
static unsigned int p_pollb(struct file *filp, poll_table *wait)
{
return p_poll(1, filp, wait);
}