/* perform a renew */
static void perform_renew(void)
{
LOG(LOG_INFO, "Performing a DHCP renew");
switch (state) {
case BOUND:
change_mode(LISTEN_KERNEL);
case RENEWING:
case REBINDING:
state = RENEW_REQUESTED;
break;
case RENEW_REQUESTED: /* impatient are we? fine, square 1 */
run_script(NULL, "deconfig");
case REQUESTING:
case RELEASED:
change_mode(LISTEN_RAW);
state = INIT_SELECTING;
break;
case INIT_SELECTING:
break;
}
/* start things over */
packet_num = 0;
/* Kill any timeouts because the user wants this to hurry along */
timeout = 0;
}
/* perform a renew */
static void perform_renew(void)
{
LOG(LOG_INFO, "Performing a DHCP renew");
switch (state) {
case BOUND:
change_mode(LISTEN_KERNEL);
case RENEWING:
case REBINDING:
state = RENEW_REQUESTED;
break;
case RENEW_REQUESTED: /* impatient are we? fine, square 1 */
run_script(NULL, "deconfig");
case REQUESTING:
case RELEASED:
change_mode(LISTEN_RAW);
state = INIT_SELECTING;
break;
case INIT_SELECTING:
}
/* start things over */
packet_num = 0;
/* Kill any timeouts because the user wants this to hurry along */
timeout = 0;
}
/* perform a release */
static void perform_release(void)
{
char buffer[16];
struct in_addr temp_addr;
/* send release packet */
if (state == BOUND || state == RENEWING || state == REBINDING) {
temp_addr.s_addr = server_addr;
sprintf(buffer, "%s", inet_ntoa(temp_addr));
temp_addr.s_addr = requested_ip;
LOG(LOG_INFO, "Unicasting a release of %s to %s",
inet_ntoa(temp_addr), buffer);
send_release(server_addr, requested_ip); /* unicast */
run_script(NULL, "deconfig");
}
LOG(LOG_INFO, "Entering released state");
change_mode(LISTEN_NONE);
state = RELEASED;
timeout = 0x7fffffff;
}
static void
gst_post_proc_tmpnoise_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstPostProc *postproc = (GstPostProc *) object;
switch (prop_id) {
case PROP_T1:
postproc->t1 = g_value_get_int (value);
break;
case PROP_T2:
postproc->t2 = g_value_get_int (value);
break;
case PROP_T3:
postproc->t3 = g_value_get_int (value);
break;
default:
gst_post_proc_set_property (object, prop_id, value, pspec);
break;
}
/* construct args */
g_free (postproc->args);
if (postproc->t1 >= 0) {
postproc->args = g_strdup_printf ("%d", postproc->t1);
if (postproc->t2 >= 0) {
append (&postproc->args, g_strdup_printf ("%d", postproc->t2));
if (postproc->t3 >= 0)
append (&postproc->args, g_strdup_printf ("%d", postproc->t3));
}
} else
postproc->args = g_strdup ("");
change_mode (postproc);
}
/* perform a release */
static void perform_release(void)
{
char buffer[16];
struct in_addr temp_addr;
/* send release packet */
if (state == BOUND || state == RENEWING || state == REBINDING) {
temp_addr.s_addr = server_addr;
sprintf(buffer, "%s", inet_ntoa(temp_addr));
temp_addr.s_addr = requested_ip;
msglogd(LOG_INFO, LOGTYPE_DHCP, "DHCPC Unicasting a release of %s to %s",
inet_ntoa(temp_addr), buffer);
if ( send_release(server_addr, requested_ip) < 0)
{
/* added by tiger 20090304, sometimes theck return value is important */
DEBUG(LOG_INFO, LOGTYPE_DHCP, "send_release error\n");
}
run_script(NULL, "release");
}
msglogd(LOG_INFO, LOGTYPE_DHCP, "DHCPC Entering released state");
change_mode(LISTEN_NONE);
state = RELEASED;
timeout = 0x7fffffff;
}
static void
gst_post_proc_deblock_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstPostProc *postproc = (GstPostProc *) object;
switch (prop_id) {
case PROP_DIFF:
postproc->diff = g_value_get_int (value);
break;
case PROP_FLAT:
postproc->flat = g_value_get_int (value);
break;
default:
gst_post_proc_set_property (object, prop_id, value, pspec);
break;
}
/* construct args */
g_free (postproc->args);
if (postproc->diff >= 0) {
postproc->args = g_strdup_printf ("%d", postproc->diff);
if (postproc->flat >= 0)
append (&postproc->args, g_strdup_printf ("%d", postproc->flat));
} else
postproc->args = g_strdup ("");
change_mode (postproc);
}
void
aoi_update(struct aoi_space * space , uint32_t id, const char * modestring , float pos[3]) {
struct object * obj = map_query(space, space->object,id);
int i;
bool set_watcher = false;
bool set_marker = false;
for (i=0;modestring[i];++i) {
char m = modestring[i];
switch(m) {
case 'w':
set_watcher = true;
break;
case 'm':
set_marker = true;
break;
case 'd':
obj->mode = MODE_DROP;
drop_object(space, obj);
return;
}
}
obj->mode &= ~MODE_DROP;
bool changed = change_mode(obj, set_watcher, set_marker);
copy_position(obj->position, pos);
if (changed || !is_near(pos, obj->last)) {
// new object or change object mode
// or position changed
copy_position(obj->last , pos);
obj->mode |= MODE_MOVE;
++obj->version;
}
}
static
void change_rot_scale(Button *m)
{
change_mode(m);
arrange_a3d_menu();
draw_button(&a3d_g2_sel);
}
static void up_btn()
{
// Depending on the state what do we do?
switch (submenu_state) {
case VIEW_SET_MODE:
as_config.mode++;
as_config.mode %= 3;
change_mode(as_config.mode);
update_menu();
break;
case VIEW_SET_PARAMS:
_printf(0,LCD_SEG_L1_3_0 , "%04x", as_read_register(ADDR_CTRL));
break;
case VIEW_STATUS:
_printf(0,LCD_SEG_L1_3_0, "%1u", as_status.all_flags);
break;
case VIEW_AXIS:
display_chars(0,LCD_SEG_L1_3_0 , "TODO", SEG_SET);
break;
default:
break;
}
/* update menu screen */
lcd_screen_activate(0);
}
static void
gst_post_proc_init (GstPostProc * postproc)
{
/* properties */
postproc->quality = DEFAULT_QUALITY;
postproc->autoq = DEFAULT_AUTOQ;
postproc->scope = DEFAULT_SCOPE;
postproc->diff = DEFAULT_DIFF;
postproc->flat = DEFAULT_FLAT;
postproc->quant = DEFAULT_QUANT;
postproc->t1 = DEFAULT_T1;
postproc->t2 = DEFAULT_T2;
postproc->t3 = DEFAULT_T3;
postproc->range = DEFAULT_RANGE;
postproc->mode = NULL;
postproc->cargs = g_strdup ("");
postproc->args = g_strdup ("");
change_mode (postproc);
postproc->context = NULL;
postproc->width = 0;
postproc->height = 0;
postproc->ystride = 0;
postproc->ustride = 0;
postproc->vstride = 0;
postproc->ysize = 0;
postproc->usize = 0;
postproc->vsize = 0;
}
void jump_rows(int jmp) {
int num_rows = model.idxtab.num_rows;
if(num_rows == 1) {
return;
}
if(mode != 'S') {
change_mode('S');
return;
}
i_idxtab_row += jmp;
if(i_idxtab_row < 0) {
i_idxtab_row = num_rows - 1;
}
else
if(i_idxtab_row >= num_rows) {
i_idxtab_row = 0;
}
print_idxtab_row_index();
}
void key_released(int key, int scan, int mod) {
switch(key) {
case GLFW_KEY_Q: glfwSetWindowShouldClose(s3d_gl_wnd, 1); break;
case GLFW_KEY_N: jump_rows(1); break;
case GLFW_KEY_P: jump_rows(-1); break;
case GLFW_KEY_M:
if(model.idxtab.num_rows == 1) { break; }
switch(mode) {
case 'A': change_mode('S'); break;
case 'S': change_mode('A'); break;
}
break;
}
}
static
void change_spin_mode(Button *m)
{
change_mode(m);
arrange_a3d_menu();
draw_button(&a3d_g2_sel);
draw_button(&a3d_g3_sel);
}
static
void change_ado_mode(Button *m)
{
change_mode(m);
arrange_a3d_menu();
a3d_disables();
draw_button(&a3d_g0_sel);
draw_button(&a3d_g4_sel);
}
static EFI_STATUS mode_auto(UINTN *mode) {
const UINT32 HORIZONTAL_MAX_OK = 1920;
const UINT32 VERTICAL_MAX_OK = 1080;
const UINT64 VIEWPORT_RATIO = 10;
UINT64 screen_area, text_area;
EFI_GUID GraphicsOutputProtocolGuid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
EFI_STATUS err;
BOOLEAN keep = FALSE;
err = LibLocateProtocol(&GraphicsOutputProtocolGuid, (VOID **)&GraphicsOutput);
if (!EFI_ERROR(err) && GraphicsOutput->Mode && GraphicsOutput->Mode->Info) {
Info = GraphicsOutput->Mode->Info;
/* Start verifying if we are in a resolution larger than Full HD
* (1920x1080). If we're not, assume we're in a good mode and do not
* try to change it. */
if (Info->HorizontalResolution <= HORIZONTAL_MAX_OK && Info->VerticalResolution <= VERTICAL_MAX_OK)
keep = TRUE;
/* For larger resolutions, calculate the ratio of the total screen
* area to the text viewport area. If it's less than 10 times bigger,
* then assume the text is readable and keep the text mode. */
else {
screen_area = (UINT64)Info->HorizontalResolution * (UINT64)Info->VerticalResolution;
text_area = text_area_from_font_size();
if (text_area != 0 && screen_area/text_area < VIEWPORT_RATIO)
keep = TRUE;
}
}
if (keep) {
/* Just clear the screen instead of changing the mode and return. */
*mode = ST->ConOut->Mode->Mode;
uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut);
return EFI_SUCCESS;
}
/* If we reached here, then we have a high resolution screen and the text
* viewport is less than 10% the screen area, so the firmware developer
* screwed up. Try to switch to a better mode. Mode number 2 is first non
* standard mode, which is provided by the device manufacturer, so it should
* be a good mode.
* Note: MaxMode is the number of modes, not the last mode. */
if (ST->ConOut->Mode->MaxMode > 2)
*mode = 2;
/* Try again with mode different than zero (assume user requests
* auto mode due to some problem with mode zero). */
else if (ST->ConOut->Mode->MaxMode == 2)
*mode = 1;
/* Else force mode change to zero. */
else
*mode = 0;
return change_mode(*mode);
}
static void
init_user_dirs () {
make_dir ("$TEXMACS_HOME_PATH");
make_dir ("$TEXMACS_HOME_PATH/bin");
make_dir ("$TEXMACS_HOME_PATH/doc");
make_dir ("$TEXMACS_HOME_PATH/doc/about");
make_dir ("$TEXMACS_HOME_PATH/doc/about/changes");
make_dir ("$TEXMACS_HOME_PATH/fonts");
make_dir ("$TEXMACS_HOME_PATH/fonts/enc");
make_dir ("$TEXMACS_HOME_PATH/fonts/error");
make_dir ("$TEXMACS_HOME_PATH/fonts/pk");
make_dir ("$TEXMACS_HOME_PATH/fonts/tfm");
make_dir ("$TEXMACS_HOME_PATH/fonts/truetype");
make_dir ("$TEXMACS_HOME_PATH/fonts/type1");
make_dir ("$TEXMACS_HOME_PATH/fonts/unpacked");
make_dir ("$TEXMACS_HOME_PATH/fonts/virtual");
make_dir ("$TEXMACS_HOME_PATH/langs");
make_dir ("$TEXMACS_HOME_PATH/langs/mathematical");
make_dir ("$TEXMACS_HOME_PATH/langs/mathematical/syntax");
make_dir ("$TEXMACS_HOME_PATH/langs/natural");
make_dir ("$TEXMACS_HOME_PATH/langs/natural/dic");
make_dir ("$TEXMACS_HOME_PATH/langs/natural/hyphen");
make_dir ("$TEXMACS_HOME_PATH/langs/programming");
make_dir ("$TEXMACS_HOME_PATH/misc");
make_dir ("$TEXMACS_HOME_PATH/misc/patterns");
make_dir ("$TEXMACS_HOME_PATH/misc/pixmaps");
make_dir ("$TEXMACS_HOME_PATH/packages");
make_dir ("$TEXMACS_HOME_PATH/plugins");
make_dir ("$TEXMACS_HOME_PATH/progs");
make_dir ("$TEXMACS_HOME_PATH/server");
make_dir ("$TEXMACS_HOME_PATH/styles");
make_dir ("$TEXMACS_HOME_PATH/system");
make_dir ("$TEXMACS_HOME_PATH/system/bib");
make_dir ("$TEXMACS_HOME_PATH/system/cache");
make_dir ("$TEXMACS_HOME_PATH/system/database");
make_dir ("$TEXMACS_HOME_PATH/system/database/bib");
make_dir ("$TEXMACS_HOME_PATH/system/tmp");
make_dir ("$TEXMACS_HOME_PATH/texts");
make_dir ("$TEXMACS_HOME_PATH/users");
change_mode ("$TEXMACS_HOME_PATH/server", 7 << 6);
change_mode ("$TEXMACS_HOME_PATH/system", 7 << 6);
change_mode ("$TEXMACS_HOME_PATH/users", 7 << 6);
clean_temp_dirs ();
}
static
void change_size_mode(Button *m)
{
change_mode(m);
arrange_a3d_menu();
draw_button(&a3d_g2_sel);
draw_button(&a3d_g3_sel);
draw_button(&a3d_g4_sel);
draw_buttontop(&a3d_sz_ratio);
}
/*
* start timelimited operation (if work in synch mode return SUCCESS)
*/
sword begin_timelimit(ora_con_t* con, int connect)
{
struct timeval* tv;
sword status;
if (synch_mode)
return OCI_SUCCESS;
if (connect || cur_asynch_mode) {
ub1 mode;
status = OCIAttrGet(con->svchp, OCI_HTYPE_SVCCTX, &mode, NULL,
OCI_ATTR_NONBLOCKING_MODE, con->errhp);
if (status != OCI_SUCCESS)
return status;
if (mode) {
status = change_mode(con);
if (status != OCI_SUCCESS)
return status;
}
cur_asynch_mode = 0;
}
status = change_mode(con);
if (status != OCI_SUCCESS && connect >= 0)
return status;
cur_asynch_mode = 1;
gettimeofday(&wtm, NULL);
tv = &request_tm;
if (connect)
tv = &restore_tm;
wtm.tv_sec += tv->tv_sec;
wtm.tv_usec += tv->tv_usec;
if (wtm.tv_usec >= 1000000) {
wtm.tv_usec -= 1000000;
++wtm.tv_sec;
}
return OCI_SUCCESS;
}
void SWNUI::changeMode_management()
{
if(change_m == true)
{
button_disableInterrupt();
change_mode();
change_m = false;
delay(CHANGE_MODE_TIME);
button_enableInterrupt();
}
}
/**
* \retval 0 Success
* \retval !0 Failure
*/
int setup_setgid(
const char * directory, /**< main directory to test in */
struct setgid_options* opts, /**< setgid_options */
struct common_options* commonOpts) /**< common_options */
{
int ret = 0;
int error_code = 0;
int mode = S_IRWXO | S_IRWXG | S_IRWXU; /* 0777 */
/* Create the directory */
ret = create_directory(directory,
mode,
commonOpts->use_pvfs2_lib,
commonOpts->verbose);
if(ret != TEST_COMMON_SUCCESS)
{
printf("\tUnable to create directory [%s]\n", directory);
}
else
{
/* Set the setgid bit on the directory */
ret = change_mode(directory,
mode | S_ISGID,
&error_code,
commonOpts->use_pvfs2_lib,
commonOpts->verbose);
if(ret != TEST_COMMON_SUCCESS)
{
printf("\tUnable to change mode on [%s]\n", directory);
}
else
{
/* Set the setgid bit on the directory */
ret = change_owner(directory,
opts->userName,
opts->user_id,
opts->groupName,
opts->group_id,
commonOpts->use_pvfs2_lib,
commonOpts->verbose);
if(ret != TEST_COMMON_SUCCESS)
{
printf("\tUnable to change ownership on [%s]\n", directory);
}
}
}
return ret;
}
int key_edit_hook(int keycode, t_env *env)
{
if (keycode == T_ESC)
return (close_edit_window(env, 0));
if (keycode == T_ENTER || keycode == T_RETURN)
copy_env_mods(env);
if (keycode == T_G || keycode == T_S || keycode == T_R || keycode == T_C)
change_mode(env, keycode);
if (keycode == T_TAB)
next_object(env);
expose_edit_hook(env);
return (1);
}
EFI_STATUS console_set_mode(UINTN *mode, enum console_mode_change_type how) {
if (how == CONSOLE_MODE_AUTO)
return mode_auto(mode);
if (how == CONSOLE_MODE_MAX) {
/* Note: MaxMode is the number of modes, not the last mode. */
if (ST->ConOut->Mode->MaxMode > 0)
*mode = ST->ConOut->Mode->MaxMode-1;
else
*mode = 0;
}
return change_mode(*mode);
}
int main(char **argv, char **environ)
{
int argc = 0;
for(int i = 0; argv[i]; i++) argc++;
struct chmod_options options;
memset(&options, 0, sizeof(struct chmod_options));
if(parse_options(argv, argc, &options) == 0 && change_mode(&options) == 0) {
sys_exit(0);
}
sys_exit(-1);
}
/**
* Starts moving a window.
*/
void ClientModel::start_resizing(Window client)
{
if (!is_visible(client))
return;
Desktop* old_desktop = m_desktops.get_category_of(client);
// Only one window, at max, can be either moved or resized
if (m_desktops.count_members_of(MOVING_DESKTOP) > 0 ||
m_desktops.count_members_of(RESIZING_DESKTOP) > 0)
return;
change_mode(client, CPS_FLOATING);
m_was_stuck[client] = old_desktop->is_all_desktop();
move_to_desktop(client, RESIZING_DESKTOP, true);
}
int main()
{
init();
init_positions();
init_buttons();
while(1)
{
if(ButtonPressed(BUTTON3, PA2))
{
change_mode();
}
process_mode(currentMode);
}
return 0;
}
static void
gst_post_proc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstPostProc *postproc = (GstPostProc *) object;
gint quality;
gchar *args;
switch (prop_id) {
case PROP_QUALITY:
quality = g_value_get_uint (value);
break;
case PROP_AUTOQ:
postproc->autoq = g_value_get_boolean (value);
break;
case PROP_SCOPE:
postproc->scope = g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
/* construct common args */
args = postproc->autoq ? g_strdup ("autoq") : g_strdup ("");
switch (postproc->scope) {
case SCOPE_BOTH:
break;
case SCOPE_CHROMA:
append (&args, g_strdup ("noluma"));
break;
case SCOPE_LUMA:
append (&args, g_strdup ("nochrom"));
break;
default:
g_assert_not_reached ();
break;
}
g_free (postproc->cargs);
postproc->cargs = args;
change_mode (postproc);
}
void as_start(uint8_t mode)
{
/* Initialize SPI interface to acceleration sensor */
AS_SPI_CTL0 |= UCSYNC | UCMST | UCMSB /* SPI master, 8 data bits, MSB first, */
| UCCKPH; /* clock idle low, data output on falling edge */
AS_SPI_CTL1 |= UCSSEL1; /* SMCLK as clock source */
AS_SPI_BR0 = AS_BR_DIVIDER; /* Low byte of division factor for baud rate */
AS_SPI_BR1 = 0x00; /* High byte of division factor for baud rate */
AS_SPI_CTL1 &= ~UCSWRST; /* Start SPI hardware */
/* Initialize interrupt pin for data read out from acceleration sensor */
AS_INT_IES &= ~AS_INT_PIN; /* Interrupt on rising edge */
#ifdef AS_DISCONNECT
/* Enable interrupt */
AS_INT_DIR &= ~AS_INT_PIN; /* Switch INT pin to input */
AS_SPI_DIR &= ~AS_SDI_PIN; /* Switch SDI pin to input */
AS_SPI_REN |= AS_SDI_PIN; /* Pulldown on SDI pin */
AS_SPI_SEL |= AS_SDO_PIN + AS_SDI_PIN + AS_SCK_PIN; /* Port pins to SDO, SDI and SCK function */
AS_CSN_OUT |= AS_CSN_PIN; /* Deselect acceleration sensor */
AS_PWR_OUT |= AS_PWR_PIN; /* Power on active high */
#endif
/* Delay of >5ms required between switching on power and configuring sensor */
timer0_delay(10, LPM3_bits);
/* Initialize interrupt pin for data read out from acceleration sensor */
AS_INT_IFG &= ~AS_INT_PIN; /* Reset flag */
AS_INT_IE |= AS_INT_PIN; /* Enable interrupt */
/* Reset sensor */
as_write_register(0x04, 0x02);
as_write_register(0x04, 0x0A);
as_write_register(0x04, 0x04);
/* Wait 5 ms before starting sensor output */
timer0_delay(5, LPM3_bits);
/* then select modality */
change_mode(mode);
}
static int voyafb_check_var(struct fb_var_screeninfo *var,
struct fb_info *info)
{
if (var->xres > XRES || var->yres > YRES
|| var->xres_virtual > XRES || var->yres_virtual > YRES
|| var->bits_per_pixel != BPP
|| var->nonstd
|| (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
return -EINVAL;
var->xres_virtual = XRES;
var->yres_virtual = YRES;
if(change_mode(var) != 0) {
return -EINVAL;
}
return 0;
}
/*
* Name: save_strokes
* Purpose: save strokes to a file
* Date: April 1, 1992
* Passed: window: pointer to current window
*/
int save_strokes( WINDOW *window )
{
FILE *fp; /* file to be written */
char name[MAX_COLS+2]; /* file name */
char line_buff[(MAX_COLS+1)*2]; /* buffer for char and attribute */
register int rc;
int prompt_line;
int fattr;
name[0] = '\0';
prompt_line = window->bottom_line;
save_screen_line( 0, prompt_line, line_buff );
/*
* name for macro file
*/
if ((rc = get_name( main19, prompt_line, name,
g_display.message_color )) == OK && *name != '\0') {
/*
* make sure it is OK to overwrite any existing file
*/
rc = get_fattr( name, &fattr );
if (rc == OK) {
/*
* overwrite existing file
*/
set_prompt( main20, prompt_line );
if (get_yn( ) != A_YES || change_mode( name, prompt_line ) == ERROR)
rc = ERROR;
}
if (rc != ERROR) {
if ((fp = fopen( name, "wb" )) != NULL) {
fwrite( ¯o.first_stroke[0], sizeof(int), MAX_KEYS, fp );
fwrite( ¯o.strokes[0], sizeof(STROKES), STROKE_LIMIT, fp );
fclose( fp );
}
}
}
restore_screen_line( 0, prompt_line, line_buff );
return( OK );
}
/* perform a release */
static void perform_release(void)
{
char buffer[16];
struct in_addr temp_addr;
/* send release packet */
if (state == BOUND || state == RENEWING || state == REBINDING) {
temp_addr.s_addr = server_addr;
sprintf(buffer, "%s", inet_ntoa(temp_addr));
temp_addr.s_addr = requested_ip;
LOG(LOG_INFO, "Unicasting a release of %s to %s",
inet_ntoa(temp_addr), buffer);
send_release(server_addr, requested_ip); /* unicast */
run_script(NULL, "deconfig");
}
LOG(LOG_INFO, "Entering released state");
change_mode(LISTEN_NONE);
state = RELEASED;
timeout = 0x7fffffff;
}
/*
* close current timelimited operation and disconnect if timeout occured
* return true only if work in asynch mode and timeout detect
*/
int done_timelimit(ora_con_t* con, sword status)
{
int ret = 0;
if (!cur_asynch_mode)
return 0;
if (remap_status(con, status) == OCI_STILL_EXECUTING) {
sword code;
status = OCIBreak(con->svchp, con->errhp);
if (status != OCI_SUCCESS)
LM_ERR("driver: %s\n",
db_oracle_error(con, status));
status = OCIReset(con->svchp, con->errhp);
if ( status == OCI_ERROR
&& OCIErrorGet(con->errhp, 1, NULL, &code,
NULL, 0, OCI_HTYPE_ERROR) == OCI_SUCCESS
&& code == 1013)
{
status = OCI_SUCCESS;
}
if (status != OCI_SUCCESS)
LM_ERR("driver: %s\n",
db_oracle_error(con, status));
db_oracle_disconnect(con);
++ret;
} else {
status = change_mode(con);
if (status != OCI_SUCCESS) {
LM_ERR("driver: %s\n", db_oracle_error(con, status));
++ret;
} else {
cur_asynch_mode = 0;
}
}
return ret;
}
