Exemplo n.º 1
0
EXPORTED int mappedfile_unlock(struct mappedfile *mf)
{
    struct timeval endtime;
    double timediff;

    int r;

    /* make this safe to call multiple times */
    if (!mf) return 0;
    if (mf->lock_status == MF_UNLOCKED) return 0;

    assert(mf->fd != -1);
    assert(!mf->dirty);

    r = lock_unlock(mf->fd, mf->fname);
    if (r < 0) {
        syslog(LOG_ERR, "IOERROR: lock_unlock %s: %m", mf->fname);
        return r;
    }

    mf->lock_status = MF_UNLOCKED;
    gettimeofday(&endtime, 0);
    timediff = timesub(&mf->starttime, &endtime);
    if (timediff > 1.0) {
        syslog(LOG_NOTICE, "mappedfile: longlock %s for %0.1f seconds",
               mf->fname, timediff);
    }

    return 0;
}
Exemplo n.º 2
0
static struct tm *
gmtsub(const time_t * const timep, const long offset, struct tm * const tmp)
{
	struct tm *	result;

	if (!gmt_is_set) {
		_MUTEX_LOCK(&gmt_mutex);
		if (!gmt_is_set) {
			gmtload(gmtptr);
			gmt_is_set = TRUE;
		}
		_MUTEX_UNLOCK(&gmt_mutex);
	}
	result = timesub(timep, offset, gmtptr, tmp);
#ifdef TM_ZONE
	/*
	** Could get fancy here and deliver something such as
	** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero,
	** but this is no time for a treasure hunt.
	*/
	if (offset != 0)
		tmp->TM_ZONE = wildabbr;
	else
		tmp->TM_ZONE = gmtptr->chars;
#endif /* defined TM_ZONE */
	return result;
}
Exemplo n.º 3
0
void timer::print() {
  std::list<split>::iterator s;
  float delta, fromstart;
  s=splits.begin();
  split &first = *s;
  split *last = &(*s);
  s++;
  std::cout << title.c_str() << "\n";
  std::cout << std::setw(10) << "split" << std::setw(10) << "last" << std::setw(10) << "total\n";
  for (; s!=splits.end(); ++s) {
    fromstart = timesub(first.when, s->when);
    delta = timesub(last->when, s->when);
    last=&(*s);
    std::cout << std::setw(10) << s->label.c_str() << "  " <<
      std::setw(10) << std::setprecision(6) << delta <<
      std::setw(10) << std::setprecision(6) << fromstart <<
      "\n";
  }
}
Exemplo n.º 4
0
static void tztime(const time_t *const timep, const char *tzstring, struct tm *const tmp)
{
	struct state *tzptr, *sp;
	const time_t t = *timep;
	register int i;
	register const struct ttinfo *ttisp;

	if (tzstring == NULL)
		tzstring = gmt;

	tzptr = (struct state *) malloc(sizeof(struct state));
	sp = tzptr;

	if (tzptr != NULL) {

		memset(tzptr, 0, sizeof(struct state));

		(void) tzparse(tzstring, tzptr, FALSE);

		if (sp->timecnt == 0 || t < sp->ats[0]) {
			i = 0;
			while (sp->ttis[i].tt_isdst)
				if (++i >= sp->typecnt) {
					i = 0;
					break;
				}
		} else {
			for (i = 1; i < sp->timecnt; ++i)
				if (t < sp->ats[i])
					break;
			i = sp->types[i - 1];	// DST begin or DST end
		}
		ttisp = &sp->ttis[i];

		/*
		   To get (wrong) behavior that's compatible with System V Release 2.0
		   you'd replace the statement below with
		   t += ttisp->tt_gmtoff;
		   timesub(&t, 0L, sp, tmp);
		 */
		if (tmp != NULL) {		/* Just a check not to assert */
			timesub(&t, ttisp->tt_gmtoff, sp, tmp);
			tmp->tm_isdst = ttisp->tt_isdst;
#if defined(HAVE_STRUCT_TM_TM_ZONE)
			tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
#endif
		}

		free(tzptr);
	}

}
Exemplo n.º 5
0
times_t
curclock(void)
{
    GTimeVal end_time;

    if(!clock_running) {
        g_fprintf(stderr,_("curclock botch\n"));
        exit(1);
    }

    g_get_current_time(&end_time);
    return timesub(end_time,start_time);
}
Exemplo n.º 6
0
/*ARGSUSED*/
static void
localsub( const time_t * const	timep,
          const long		offset,
          struct tm * const	tmp )
{
	register struct state *		sp;
	register const struct ttinfo *	ttisp;
	register int			i;
	const time_t			t = *timep;
        long useless;
	
	useless = offset; /* Removes a warning */
	sp = lclptr;
	if (sp->timecnt == 0 || t < sp->ats[0]) {
		i = 0;
		while (sp->ttis[i].tt_isdst) {
			if (++i >= sp->typecnt) {
				i = 0;
				break;
			}
      }
	} 
   else {
		for (i = 1; i < sp->timecnt; ++i) {
			if (t < sp->ats[i]) break;
      }
		i = sp->types[i - 1];
	}
	ttisp = &sp->ttis[i];
	/*
	** To get (wrong) behavior that's compatible with System V Release 2.0
	** you'd replace the statement below with
	**	t += ttisp->tt_gmtoff;
	**	timesub(&t, 0L, sp, tmp);
	*/
	timesub(&t, ttisp->tt_gmtoff, sp, tmp);
	tmp->tm_isdst = ttisp->tt_isdst;
	tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind];
#ifdef TM_ZONE
	tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];
#endif /* defined TM_ZONE */
}
Exemplo n.º 7
0
/*
 * gmtsub is to gmtime as localsub is to localtime.
 */
static struct pg_tm *
gmtsub(const pg_time_t *timep, long offset, struct pg_tm * tmp)
{
	struct pg_tm *result;

	if (!gmt_is_set)
	{
		gmt_is_set = TRUE;
		gmtload(gmtptr);
	}
	result = timesub(timep, offset, gmtptr, tmp);

	/*
	 * Could get fancy here and deliver something such as "UTC+xxxx" or
	 * "UTC-xxxx" if offset is non-zero, but this is no time for a treasure
	 * hunt.
	 */
	if (offset != 0)
		tmp->tm_zone = wildabbr;
	else
		tmp->tm_zone = gmtptr->chars;

	return result;
}
Exemplo n.º 8
0
/*
 * The easy way to behave "as if no library function calls" localtime
 * is to not call it--so we drop its guts into "localsub", which can be
 * freely called. (And no, the PANS doesn't require the above behavior--
 * but it *is* desirable.)
 *
 * The unused offset argument is for the benefit of mktime variants.
 */
static struct pg_tm *
localsub(const pg_time_t *timep, long offset,
		 struct pg_tm * tmp, const pg_tz *tz)
{
	const struct state *sp;
	const struct ttinfo *ttisp;
	int			i;
	struct pg_tm *result;
	const pg_time_t t = *timep;

	sp = &tz->state;
	if ((sp->goback && t < sp->ats[0]) ||
		(sp->goahead && t > sp->ats[sp->timecnt - 1]))
	{
		pg_time_t	newt = t;
		pg_time_t	seconds;
		pg_time_t	tcycles;
		int64		icycles;

		if (t < sp->ats[0])
			seconds = sp->ats[0] - t;
		else
			seconds = t - sp->ats[sp->timecnt - 1];
		--seconds;
		tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
		++tcycles;
		icycles = tcycles;
		if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
			return NULL;
		seconds = icycles;
		seconds *= YEARSPERREPEAT;
		seconds *= AVGSECSPERYEAR;
		if (t < sp->ats[0])
			newt += seconds;
		else
			newt -= seconds;
		if (newt < sp->ats[0] ||
			newt > sp->ats[sp->timecnt - 1])
			return NULL;		/* "cannot happen" */
		result = localsub(&newt, offset, tmp, tz);
		if (result == tmp)
		{
			pg_time_t	newy;

			newy = tmp->tm_year;
			if (t < sp->ats[0])
				newy -= icycles * YEARSPERREPEAT;
			else
				newy += icycles * YEARSPERREPEAT;
			tmp->tm_year = newy;
			if (tmp->tm_year != newy)
				return NULL;
		}
		return result;
	}
	if (sp->timecnt == 0 || t < sp->ats[0])
	{
		i = 0;
		while (sp->ttis[i].tt_isdst)
			if (++i >= sp->typecnt)
			{
				i = 0;
				break;
			}
	}
	else
	{
		int			lo = 1;
		int			hi = sp->timecnt;

		while (lo < hi)
		{
			int			mid = (lo + hi) >> 1;

			if (t < sp->ats[mid])
				hi = mid;
			else
				lo = mid + 1;
		}
		i = (int) sp->types[lo - 1];
	}
	ttisp = &sp->ttis[i];

	result = timesub(&t, ttisp->tt_gmtoff, sp, tmp);
	tmp->tm_isdst = ttisp->tt_isdst;
	tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
	return result;
}
Exemplo n.º 9
0
int main(int argc, char **argv)
{
    int opt;
    pid_t pid;
    char *alt_config = NULL;
    time_t runattime = 0;
    int upgrade = 0;

    if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
        fatal("must run as the Cyrus user", EC_USAGE);
    }

    while ((opt = getopt(argc, argv, "C:dt:U")) != EOF) {
        switch (opt) {
        case 'C': /* alt config file */
            alt_config = optarg;
            break;
        case 'd': /* don't fork. debugging mode */
            debugmode = 1;
            break;
        case 't': /* run a single scan at this time */
            runattime = atoi(optarg);
            break;
        case 'U':
            upgrade = 1;
            break;
        default:
            fprintf(stderr, "invalid argument\n");
            exit(EC_USAGE);
            break;
        }
    }

    cyrus_init(alt_config, "calalarmd", 0, 0);

    mboxlist_init(0);
    mboxlist_open(NULL);

    quotadb_init(0);
    quotadb_open(NULL);

    annotatemore_open();

    caldav_init();

    mboxevent_init();

    if (upgrade) {
        caldav_alarm_upgrade();
        shut_down(0);
    }

    if (runattime) {
        caldav_alarm_process(runattime);
        shut_down(0);
    }

    signals_set_shutdown(shut_down);
    signals_add_handlers(0);

    /* fork unless we were given the -d option or we're running as a daemon */
    if (debugmode == 0 && !getenv("CYRUS_ISDAEMON")) {

        pid = fork();

        if (pid == -1) {
            perror("fork");
            exit(1);
        }

        if (pid != 0) { /* parent */
            exit(0);
        }
    }
    /* child */

    for (;;) {
        struct timeval start, end;
        double totaltime;
        int tosleep;

        signals_poll();

        gettimeofday(&start, 0);
        caldav_alarm_process(0);
        gettimeofday(&end, 0);

        signals_poll();

        totaltime = timesub(&start, &end);
        tosleep = 10 - (int) (totaltime + 0.5); /* round to nearest int */
        if (tosleep > 0)
            sleep(tosleep);
    }

    /* NOTREACHED */
    shut_down(1);
}
Exemplo n.º 10
0
static int handle_input(void)
{
    static struct timeval pressed;
    static int long_press;
    struct timeval now, diff;
    unsigned long key;
    int rc;

    serial_poll();

    if (pressed.tv_sec && pressed.tv_usec) {
	gettimeofday(&now, NULL);
	timesub(&diff, &now, &pressed);
	/* LONG_PRESS? */
	if (diff.tv_sec >= 1) {
	    switch (visual) {
	    case VIEW_SATS:  visual = VIEW_MAP; break;
	    case VIEW_MAP:   visual = VIEW_ROUTE; break;
	    case VIEW_ROUTE: visual = VIEW_SATS; break;
	    }
	    /* allow for cycling by keeping the button pressed */
	    pressed.tv_sec  = now.tv_sec;
	    pressed.tv_usec = now.tv_usec;
	    long_press = 1;
	    do_refresh = 1;
	    return 0;
	}
    }

    rc = empeg_getkey(&key);
    if (rc != 1) return rc;

    switch(key) {
    case IR_TOP_BUTTON_PRESSED:
	if (!load_route && !menu)
	    return 1; /* done, wait to be selected again in the hijack menu */

	load_route = 0;
	menu = 0;
	do_refresh = 1;
	break;

    case IR_BOTTOM_BUTTON_PRESSED:
	gettimeofday(&pressed, NULL);
	break;

    case IR_BOTTOM_BUTTON_RELEASED:
	pressed.tv_sec = pressed.tv_usec = 0;
	if (long_press) {
	    long_press = 0;
	    break;
	}
	if (load_route) {
	    route_load();
	    load_route = 0;
	    menu = 0;
	}
	else if (menu) {
	    switch(menu_pos) {
	    case 0: load_route = routes_init(); break;
	    case 1:
		switch (visual) {
		case VIEW_SATS:  visual = VIEW_MAP; break;
		case VIEW_MAP:   visual = VIEW_ROUTE; break;
		case VIEW_ROUTE: visual = VIEW_SATS; break;
		}
		break;
	    case 2:
		if (++show_popups == 3)
		    show_popups = 0;
		break;
	    case 3: show_metric = 1 - show_metric; break;
	    case 4: show_gpscoords = 1 - show_gpscoords;  break;
	    case 5: show_time = 1 - show_time; break;
	    case 6: show_track = 1 - show_track; break;
	    case 7:
		if (++coord_format == 3)
		    coord_format = 0;
		break;
	    }
	    menu = 0; lastmenu = 3; lastmenu_pos = menu_pos;
	}
	else
	    menu = 1;

	do_refresh = 1;
	break;

    case IR_LEFT_BUTTON_PRESSED:
	if (load_route)
	    route_select(0);
	else if (menu) {
	    if (--menu_pos < 0)
		menu_pos = MENU_ENTRIES - 1;
	}
	else {
	    switch (visual) {
	    case VIEW_SATS:  break;
	    case VIEW_MAP:   draw_zoom(0); break;
	    case VIEW_ROUTE: route_skipwp(-1); break;
	    }
	}
	do_refresh = 1;
	break;

    case IR_RIGHT_BUTTON_PRESSED:
	if (load_route)
	    route_select(1);
	else if (menu) {
	    if (++menu_pos >= MENU_ENTRIES)
		menu_pos = 0;
	}
	else {
	    switch (visual) {
	    case VIEW_SATS:  break;
	    case VIEW_MAP:   draw_zoom(1); break;
	    case VIEW_ROUTE: route_skipwp(1); break;
	    }
	}
	do_refresh = 1;
	break;

    case IR_KNOB_LEFT:
    case IR_KNOB_RIGHT:
	route_skipwp(key == IR_KNOB_LEFT ? -1 : 1);
	route_locate();
	do_refresh = 1;
	break;

    case IR_KNOB_PRESSED:
    default:
	break;
    }

    return 0;
}
Exemplo n.º 11
0
/* Link up the TaperSource with the Device, including retries etc. */
static void run_device_output(taper_state_t * taper_state,
                              dump_info_t * dump_info) {
    GValue val;
    guint file_number;
    dump_info->current_part = 1;
    dump_info->total_time.tv_sec = 0;
    dump_info->total_time.tv_usec = 0;
    dump_info->total_bytes = 0;

    for (;;) {
        GTimeVal start_time, end_time, run_time;
        StreamingRequirement streaming_mode;
        queue_result_flags queue_result;
        CountingConsumerData consumer_data;
        dumpfile_t *this_header;
        size_t max_memory;
        
        this_header = munge_headers(dump_info);
        if (this_header == NULL) {
            char * qdiskname = quote_string(dump_info->diskname);
	    char * errstr = taper_source_get_errmsg(dump_info->source);
	    if (!errstr)
		errstr = "Failed reading dump header.";
	    errstr = quote_string(errstr);
            putresult(FAILED,
             "%s INPUT-ERROR TAPE-GOOD %s \"\"\n",
                      dump_info->handle, errstr);
            log_add(L_FAIL, "%s %s %s %d %s",
                    dump_info->hostname, qdiskname, dump_info->timestamp,
                    dump_info->level, errstr);
            amfree(qdiskname);
	    amfree(errstr);
            return;
        }            

        if (!find_and_label_new_tape(taper_state, dump_info)) {
            bail_no_volume(dump_info, taper_state->last_errmsg);
	    dumpfile_free(this_header);
            return;
        }

	while (!device_start_file(taper_state->device, this_header)) {
            /* Close the device. */
            device_finish(taper_state->device);
            g_object_unref(taper_state->device);
            taper_state->device = NULL;

            if (!find_and_label_new_tape(taper_state, dump_info)) {
		bail_no_volume(dump_info, taper_state->last_errmsg);
		dumpfile_free(this_header);
		return;
            }
        }
	dumpfile_free(this_header);

        bzero(&val, sizeof(val));
        if (!device_property_get(taper_state->device, PROPERTY_STREAMING, &val)
            || !G_VALUE_HOLDS(&val, STREAMING_REQUIREMENT_TYPE)) {
            g_fprintf(stderr, "taper: Couldn't get streaming type!\n");
            streaming_mode = STREAMING_REQUIREMENT_REQUIRED;
        } else {
            streaming_mode = g_value_get_enum(&val);
        }
    
        file_number = taper_state->device->file;

        consumer_data.next_consumer = device_write_consumer;
        consumer_data.next_consumer_data = taper_state->device;
        consumer_data.bytes_written = 0;

        g_get_current_time(&start_time);

        if (getconf_seen(CNF_DEVICE_OUTPUT_BUFFER_SIZE)) {
            max_memory = getconf_size(CNF_DEVICE_OUTPUT_BUFFER_SIZE);
            if (getconf_seen(CNF_TAPEBUFS)) {
                g_fprintf(stderr,
                        "Configuration directives 'device_output_buffer_size' "
                        "and \n"
                        "'tapebufs' are incompatible; using former.\n");
            }
        } else if (getconf_seen(CNF_TAPEBUFS)) {
            max_memory = getconf_int(CNF_TAPEBUFS) *
                taper_state->device->block_size;
        } else {
            /* Use default. */
            max_memory = getconf_size(CNF_DEVICE_OUTPUT_BUFFER_SIZE);
        }

        queue_result = do_consumer_producer_queue_full
            (taper_source_producer,
             dump_info->source,
             counting_consumer,
             &consumer_data,
             taper_state->device->block_size, max_memory,
             streaming_mode);

        g_get_current_time(&end_time);
        run_time = timesub(end_time, start_time);

        /* The device_write_consumer leaves the file open, so close it now. */
        if (!device_finish_file(taper_state->device)) {
            queue_result = queue_result | QUEUE_CONSUMER_ERROR;
        }

        if (!finish_part_attempt(taper_state, dump_info, queue_result,
                                 run_time, consumer_data.bytes_written)) {
            break;
        }
    }
}
Exemplo n.º 12
0
int main(int argc, char *argv[])
{
  unsigned long flags = 0;
  int fd, size, r;
  char *buffer;
  struct timeval starttime, firsttime, nowtime, tm, t0, t1;
  pkt_asm_list_t list;
  int first = 1;

  argument_read(&argc, argv, args);
  if (ifname == NULL)
    error_exit("Unknown interface.\n");
  if (complete) flags |= PKT_SEND_FLAG_COMPLETE;
  if (interval) flags |= PKT_SEND_FLAG_INTERVAL;

  fd = pkthandler.open_send(ifname, flags);

  buffer = malloc(bufsize);
  if (buffer == NULL)
    error_exit("Out of memory.\n");

  while (!terminated) {
    list = pkt_asm_list_create();
    size = pkt_text_read(stdin, buffer, bufsize, NULL, NULL, &tm, list);
    if (size < 0)
      break;
    if (size == bufsize)
      error_exit("Out of buffer.\n");

    pkt_assemble_ethernet(list, buffer, size);
    list = pkt_asm_list_destroy(list);

    if (pkt_asm_list_filter_args(NULL, argc, argv) == 0) {
      list = pkt_asm_list_create();
      pkt_disasm_ethernet(list, buffer, size);
      r = pkt_asm_list_filter_args(list, argc, argv);
      list = pkt_asm_list_destroy(list);
      if (r >= 0) {
	if (filrev) r = !r;
	if (r == 0) continue;
      }
    }

    list = pkt_asm_list_create();
    pkt_asm_list_read_args(list, argc, argv);
    pkt_assemble_ethernet(list, buffer, size);
    list = pkt_asm_list_destroy(list);

    if ((flags & PKT_SEND_FLAG_INTERVAL) && (tm.tv_sec || tm.tv_usec)) {
      if (first) {
	firsttime.tv_sec  = tm.tv_sec;
	firsttime.tv_usec = tm.tv_usec;
	gettimeofday(&starttime, NULL);
	first = 0;
      } else {
	gettimeofday(&nowtime, NULL);
	if (timesub(&t0, &tm, &firsttime) == 0)
	  if (timesub(&t1, &nowtime, &starttime) == 0)
	    if (timesub(&t0, &t0, &t1) == 0)
	      select(0, NULL, NULL, NULL, &t0);
	if (justbefore) {
	  firsttime.tv_sec  = tm.tv_sec;
	  firsttime.tv_usec = tm.tv_usec;
	  starttime.tv_sec  = nowtime.tv_sec;
	  starttime.tv_usec = nowtime.tv_usec;
	}
      }
    }

    signal(SIGINT , sigint_handler);
    signal(SIGTERM, sigint_handler);
    pkthandler.send(fd, buffer, size);
    signal(SIGINT , SIG_DFL);
    signal(SIGTERM, SIG_DFL);

    if (waitusec > 0)
      usleep(waitusec);
  }

  free(buffer);

  close(fd);

  return 0;
}
Exemplo n.º 13
0
/*ARGSUSED*/
static struct tm *
localsub(const time_t * const timep, const long offset __unused,
	 struct tm * const tmp)
{
	struct state *		sp;
	const struct ttinfo *	ttisp;
	int			i;
	struct tm *		result;
	const time_t		t = *timep;

	sp = lclptr;

	if ((sp->goback && t < sp->ats[0]) ||
		(sp->goahead && t > sp->ats[sp->timecnt - 1])) {
			time_t		newt = t;
			time_t		seconds;
			time_t		tcycles;
			int_fast64_t	icycles;

			if (t < sp->ats[0])
				seconds = sp->ats[0] - t;
			else	seconds = t - sp->ats[sp->timecnt - 1];
			--seconds;
			tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
			++tcycles;
			icycles = tcycles;
			if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
				return NULL;
			seconds = icycles;
			seconds *= YEARSPERREPEAT;
			seconds *= AVGSECSPERYEAR;
			if (t < sp->ats[0])
				newt += seconds;
			else	newt -= seconds;
			if (newt < sp->ats[0] ||
				newt > sp->ats[sp->timecnt - 1])
					return NULL;	/* "cannot happen" */
			result = localsub(&newt, offset, tmp);
			if (result == tmp) {
				time_t	newy;

				newy = tmp->tm_year;
				if (t < sp->ats[0])
					newy -= icycles * YEARSPERREPEAT;
				else	newy += icycles * YEARSPERREPEAT;
				tmp->tm_year = newy;
				if (tmp->tm_year != newy)
					return NULL;
			}
			return result;
	}
	if (sp->timecnt == 0 || t < sp->ats[0]) {
		i = 0;
		while (sp->ttis[i].tt_isdst)
			if (++i >= sp->typecnt) {
				i = 0;
				break;
			}
	} else {
		int	lo = 1;
		int	hi = sp->timecnt;

		while (lo < hi) {
			int	mid = (lo + hi) >> 1;

			if (t < sp->ats[mid])
				hi = mid;
			else	lo = mid + 1;
		}
		i = (int) sp->types[lo - 1];
	}
	ttisp = &sp->ttis[i];
	/*
	** To get (wrong) behavior that's compatible with System V Release 2.0
	** you'd replace the statement below with
	**	t += ttisp->tt_gmtoff;
	**	timesub(&t, 0L, sp, tmp);
	*/
	result = timesub(&t, ttisp->tt_gmtoff, sp, tmp);
	tmp->tm_isdst = ttisp->tt_isdst;
	tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind];
#ifdef TM_ZONE
	tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];
#endif /* defined TM_ZONE */
	return result;
}