static GnmSolverResult *
run_solver (SolverState *state, GnmSolverParameters *param)
{
GError *err = NULL;
gboolean ok;
GnmSheetRange sr;
GOUndo *undo = NULL;
GnmSolver *sol = NULL;
GnmValue const *vinput;
GtkWindow *top = GTK_WINDOW (gtk_widget_get_toplevel (state->dialog));
GnmSolverResult *res = NULL;
state->ref_count++;
sol = gnm_solver_factory_functional (param->options.algorithm,
state->wbcg)
? gnm_solver_factory_create (param->options.algorithm, param)
: NULL;
if (!sol) {
go_gtk_notice_dialog (top, GTK_MESSAGE_ERROR,
_("The chosen solver is not functional."));
goto fail;
}
gtk_notebook_set_current_page (GTK_NOTEBOOK (state->notebook), -1);
state->run.solver = sol;
vinput = gnm_solver_param_get_input (param);
gnm_sheet_range_from_value (&sr, vinput);
if (!sr.sheet) sr.sheet = param->sheet;
undo = clipboard_copy_range_undo (sr.sheet, &sr.range);
g_signal_connect_swapped (G_OBJECT (sol),
"notify::status",
G_CALLBACK (cb_notify_status),
state);
g_signal_connect_swapped (G_OBJECT (sol),
"notify::reason",
G_CALLBACK (cb_notify_status),
state);
cb_notify_status (state);
g_signal_connect_swapped (G_OBJECT (sol),
"notify::result",
G_CALLBACK (cb_notify_result),
state);
cb_notify_result (state);
state->run.timer_source = g_timeout_add_seconds
(1, (GSourceFunc)cb_timer_tick, state);
cb_timer_tick (state);
/* ---------------------------------------- */
ok = gnm_solver_start (sol,
GNM_WBC (state->wbcg),
&err);
if (ok) {
state->run.in_main++;
go_cmd_context_set_sensitive (GO_CMD_CONTEXT (state->wbcg), FALSE);
gtk_main ();
go_cmd_context_set_sensitive (GO_CMD_CONTEXT (state->wbcg), TRUE);
state->run.in_main--;
ok = gnm_solver_has_solution (sol);
} else if (err) {
gnm_solver_set_reason (sol, err->message);
}
g_clear_error (&err);
remove_objective_value_source (state);
remove_timer_source (state);
/* ---------------------------------------- */
if (ok) {
GOUndo *redo;
gnm_solver_store_result (sol);
redo = clipboard_copy_range_undo (sr.sheet, &sr.range);
if (param->options.program_report ||
param->options.sensitivity_report) {
Workbook *wb = param->sheet->workbook;
GOUndo *undo_report, *redo_report;
undo_report = go_undo_binary_new
(wb,
workbook_sheet_state_new (wb),
(GOUndoBinaryFunc)workbook_sheet_state_restore,
NULL,
(GFreeFunc)workbook_sheet_state_free);
undo = go_undo_combine (undo, undo_report);
create_report (sol, state);
redo_report = go_undo_binary_new
(wb,
workbook_sheet_state_new (wb),
(GOUndoBinaryFunc)workbook_sheet_state_restore,
NULL,
(GFreeFunc)workbook_sheet_state_free);
redo = go_undo_combine (redo, redo_report);
}
cmd_generic (GNM_WBC (state->wbcg),
_("Running solver"),
undo, redo);
res = g_object_ref (sol->result);
undo = redo = NULL;
}
fail:
if (undo)
g_object_unref (undo);
if (state->run.solver) {
g_object_unref (state->run.solver);
state->run.solver = NULL;
}
unref_state (state);
return res;
}
int
snmp_agent_parse(
snmp_session *session,
uint8 *indata,
int inlength,
uint8 *outdata,
int *outlength
)
{
uint8 msgtype, type;
long zero = 0;
long reqid, errstat, errindex, dummyindex;
uint8 *out_auth, *out_header, *out_reqid;
uint8 *startData = indata;
int startLength = inlength;
long version;
uint8 *origdata = indata;
int origlen = inlength;
// usecEntry *ue;
int packet_len, ret = 0;
#ifdef WEBADMIN
int newoutdata; // add -- by arius 5/17/2000
int len; // add -- by arius 5/17/2000
#endif WEBADMIN
session->community_len = COMMUNITY_MAX_LEN;
//get community name
indata = snmp_parse_auth(indata, &inlength, community, &session->community_len, &version);
if (indata == NULL){
// increment_stat( SNMP_STAT_ENCODING_ERRORS );
ERROR("bad auth encoding");
return 0;
}
#if 1 //ONLY SUPPORT VERSION 1
if(version != SNMP_VERSION_1) {
ERROR("wrong version");
snmp_inbadversions++;
return 0;
}
#else ////////////////////////////////////////////
if( version != SNMP_VERSION_1 && version != SNMP_VERSION_2C && version != SNMP_VERSION_2 ) {
// increment_stat( SNMP_STAT_ENCODING_ERRORS );
ERROR("wrong version");
snmp_inbadversions++;
return 0;
}
if( version == SNMP_VERSION_2C || version == SNMP_VERSION_2 ) {
if( version == SNMP_VERSION_2 ) {
ret = check_auth( session, origdata, origlen, indata - session->community_len, session->community_len, &ue );
*outlength = (SNMP_MAX_LEN < session->MMS) ? SNMP_MAX_LEN : session->MMS;
session->MMS = SNMP_MAX_LEN;
} else if( version == SNMP_VERSION_2C ) {
ret = community_auth( session );
session->version = SNMP_VERSION_2C;
}
if( ret < 0 ) {
// increment_stat( -ret );
if( (indata=asn_parse_header(indata, &inlength, &msgtype))
&& asn_parse_int(indata, &inlength, &type, &reqid, sizeof(reqid)) )
{
if( msgtype == REPORT_MSG ) return 0;
if( !(session->qoS & USEC_QOS_GENREPORT) ) return 0;
session->agentBoots = _agentBoots;
session->agentClock = _agentStartTime;
memcpy( session->agentID, _agentID, 12 );
session->MMS = SNMP_MAX_LEN;
create_report( session, outdata, outlength, -ret, reqid );
return 1;
} else {
return 0;
}
} else if( ret > 0 ) {
// increment_stat( ret );
return 0;
}
} else {
#endif /////////////////////////////////////////////////////
//VERSION 1
if(community_auth( session )==0) return 0;
// session->version = SNMP_VERSION_1;
#if 0 ////////
}
#endif ///////
indata = asn_parse_header(indata, &inlength, &msgtype);
if (indata == NULL){
// increment_stat( SNMP_STAT_ENCODING_ERRORS );
ERROR("bad header");
return 0;
}
// XXX: increment by total number of vars at correct place:
snmp_intotalreqvars++;
if(msgtype == GET_REQ_MSG) snmp_ingetrequests++;
else if (msgtype == GETNEXT_REQ_MSG) snmp_ingetnexts++;
else if (msgtype == SET_REQ_MSG) snmp_insetrequests++;
else return 0;
// if (msgtype == GETBULK_REQ_MSG: //version 2
// Request ID
indata = asn_parse_int(indata, &inlength, &type, &reqid, sizeof(reqid));
if (indata == NULL){
// increment_stat( SNMP_STAT_ENCODING_ERRORS );
ERROR("bad parse of reqid");
return 0;
}
//Error Status
indata = asn_parse_int(indata, &inlength, &type, &errstat, sizeof(errstat));
if (indata == NULL){
// increment_stat( SNMP_STAT_ENCODING_ERRORS );
ERROR("bad parse of errstat");
snmp_inasnparseerrors++;
return 0;
}
//Error Index
indata = asn_parse_int(indata, &inlength, &type, &errindex, sizeof(errindex));
if (indata == NULL){
// increment_stat( SNMP_STAT_ENCODING_ERRORS );
ERROR("bad parse of errindex");
return 0;
}
//
// Now start cobbling together what is known about the output packet.
// The final lengths are not known now, so they will have to be recomputed
// later.
//
// setup for response
//Simon time( (time_t *) &session->agentTime );
//Simon session->agentClock = _agentStartTime;
//Simon session->agentBoots = _agentBoots;
//Simon memcpy( session->agentID, _agentID, 12 );
out_auth = outdata;
//Set Resp Community
out_header = snmp_build_auth(out_auth, outlength,
community,session->community_len,
(long)SNMP_VERSION_1,0);
if (out_header == NULL){
ERROR("snmp_build_auth failed");
snmp_inasnparseerrors++;
return 0;
}
out_reqid = asn_build_sequence(out_header, outlength, (uint8)GET_RSP_MSG, 0);
if (out_reqid == NULL){
ERROR("out_reqid == NULL");
return 0;
}
//Set Resp ID
type = (uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER);
// return identical request id
outdata = asn_build_int(out_reqid, outlength, type, &reqid, sizeof(reqid));
if (outdata == NULL){
ERROR("build reqid failed");
return 0;
}
// assume that error status will be zero
outdata = asn_build_int(outdata, outlength, type, &zero, sizeof(zero));
if (outdata == NULL){
ERROR("build errstat failed");
return 0;
}
// assume that error index will be zero
outdata = asn_build_int(outdata, outlength, type, &zero, sizeof(zero));
if (outdata == NULL){
ERROR("build errindex failed");
return 0;
}
#if 0 ///////////////////////////////////////////
if (msgtype == GETBULK_REQ_MSG)
errstat = bulk_var_op_list(indata, inlength, outdata, *outlength,
errstat, errindex, &errindex );
else
#endif 0 ////////////////////////////////////////
errstat = parse_var_op_list(session, indata, inlength, outdata, *outlength,
&errindex, msgtype, RESERVE1);
if (msgtype== SET_REQ_MSG){
if (errstat == SNMP_ERR_NOERROR)
errstat = parse_var_op_list(session, indata, inlength, outdata, *outlength,
&errindex, msgtype, RESERVE2);
if (errstat == SNMP_ERR_NOERROR){
//
//* SETS require 3-4 passes through the var_op_list. The first two
//* passes verify that all types, lengths, and values are valid
//* and may reserve resources and the third does the set and a
//* fourth executes any actions. Then the identical GET RESPONSE
//* packet is returned.
//* If either of the first two passes returns an error, another
//* pass is made so that any reserved resources can be freed.
//*
parse_var_op_list(session, indata, inlength, outdata, *outlength,
&dummyindex, msgtype, COMMIT);
parse_var_op_list(session, indata, inlength, outdata, *outlength,
&dummyindex, msgtype, ACTION);
if (create_identical(session, startData, out_auth, startLength, 0L, 0L )){
*outlength = packet_end - out_auth;
return 1;
}
return 0;
} else {
parse_var_op_list(session, indata, inlength, outdata, *outlength,
&dummyindex, msgtype, COMM_FREE);
}
}
switch((short)errstat){
case SNMP_ERR_NOERROR:
// re-encode the headers with the real lengths
*outlength = packet_end - out_header;
packet_len = *outlength;
outdata = asn_build_sequence(out_header, outlength, GET_RSP_MSG,
packet_end - out_reqid);
// add --- By arius 5/17/2000
#ifdef WEBADMIN
newoutdata = packet_end - outdata; // how many shifts
len = packet_end - out_reqid;
packet_end = outdata; // save new pointer end of packet
outdata -= len;
out_reqid = out_reqid - newoutdata;
#endif WEBADMIN
// end of here
if (outdata != out_reqid){
ERROR("internal error: header");
return 0;
}
*outlength = packet_end - out_auth;
outdata = snmp_build_auth(out_auth, outlength,
community, session->community_len,
(long)SNMP_VERSION_1,
packet_end - out_header );
// add --- By arius 5/17/2000
#ifdef WEBADMIN
out_header -= (packet_end - outdata);
packet_end = outdata; // save new pointer end of packet
#endif WEBADMIN
// end of here
*outlength = packet_end - out_auth;
#if 0
// packet_end is correct for old SNMP. This dichotomy needs to be fixed.
if (session->version == SNMP_VERSION_2)
packet_end = out_auth + packet_len;
#endif
break;
case SNMP_ERR_TOOBIG:
snmp_intoobigs++;
#if notdone
if (session->version == SNMP_VERSION_2){
create_toobig(out_auth, *outlength, reqid, pi);
break;
} // else FALLTHRU
#endif
case SNMP_ERR_NOACCESS:
case SNMP_ERR_WRONGTYPE:
case SNMP_ERR_WRONGLENGTH:
case SNMP_ERR_WRONGENCODING:
case SNMP_ERR_WRONGVALUE:
case SNMP_ERR_NOCREATION:
case SNMP_ERR_INCONSISTENTVALUE:
case SNMP_ERR_RESOURCEUNAVAILABLE:
case SNMP_ERR_COMMITFAILED:
case SNMP_ERR_UNDOFAILED:
case SNMP_ERR_AUTHORIZATIONERROR:
case SNMP_ERR_NOTWRITABLE:
case SNMP_ERR_INCONSISTENTNAME:
case SNMP_ERR_NOSUCHNAME:
case SNMP_ERR_BADVALUE:
case SNMP_ERR_READONLY:
case SNMP_ERR_GENERR:
if (create_identical(session, startData, out_auth, startLength, errstat,
errindex)){
*outlength = packet_end - out_auth;
return 1;
}
return 0;
default:
return 0;
}
#if 0
if( session->qoS & USEC_QOS_AUTH ) {
md5Digest( out_auth, *outlength, outdata - (session->contextLen + 16),
outdata - (session->contextLen + 16) );
}
#endif
return 1;
}