GBool SecurityHandler::checkEncryption(GooString *ownerPassword, GooString *userPassword) { void *authData; GBool ok; int i; if (ownerPassword || userPassword) { authData = makeAuthData(ownerPassword, userPassword); } else { authData = NULL; } ok = authorize(authData); if (authData) { freeAuthData(authData); } for (i = 0; !ok && i < 3; ++i) { if (!(authData = getAuthData())) { break; } ok = authorize(authData); if (authData) { freeAuthData(authData); } } if (!ok) { error(-1, "Incorrect password"); } return ok; }
// Return 1 if request is authorised, 0 otherwise. static int check_authorization(struct mg_connection *conn, const char *path) { char fname[PATH_MAX]; struct vec uri_vec, filename_vec; const char *list; FILE *fp = NULL; int authorized = 1; list = conn->ctx->config[PROTECT_URI]; while ((list = next_option(list, &uri_vec, &filename_vec)) != NULL) { if (!memcmp(conn->request_info.uri, uri_vec.ptr, uri_vec.len)) { mg_snprintf(fname, sizeof(fname), "%.*s", (int) filename_vec.len, filename_vec.ptr); fp = mg_fopen(fname, "r"); break; } } if (fp == NULL) { fp = open_auth_file(conn, path); } if (fp != NULL) { authorized = authorize(conn, fp); fclose(fp); } return authorized; }
void main (int argc, char *argu[]) { char *name, *pass; size_t n; int ii, flags = GoKeepEnviron; for (ii = 1; ii < argc; ii++) { if (argu[ii][0] != '-' || argu[ii][1] == 0) break; if (argu[ii][1] == '-' && argu[ii][2] == 0) { ii++; break; } for (int jj = 1; argu[ii][jj]; jj++) switch (argu[ii][jj]) { case 'l': flags |= GoChdirHome; flags &= ~GoKeepEnviron; break; default: errx ("bad option %c", argu[ii][jj]); } } name = ii >= argc ? "root" : argu[ii]; pass = getpass ("Password: "******"Denied\n", stdout); errx (1, "authorization failed"); }
void OAuthWizard::authorize() { ui_p->pinEdit->setEnabled( false ); QOAuth::ParamMap otherArgs; otherArgs.insert( ParamVerifier, ui_p->pinEdit->text().toAscii() ); QOAuth::ParamMap accessToken = qoauth->accessToken( TwitterAccessTokenURL, QOAuth::POST, token, tokenSecret, QOAuth::HMAC_SHA1, otherArgs ); if ( qoauth->error() != QOAuth::NoError ) { ui_p->pinEdit->hide(); ui_p->pinLabel->setText( tr( "Either the PIN you entered is incorrect, or a network-related problem occured. Please try again later." ) ); ui_p->okButton->setText( tr( "Retry" ) ); adjustSize(); resize( width(), height() * 1.5 ); disconnect( ui_p->okButton, SIGNAL(clicked()), this, SLOT(authorize()) ); connect( ui_p->okButton, SIGNAL(clicked()), this, SLOT(openUrl()) ); state = false; return; } screenName = accessToken.value( ParamScreenName ); token = accessToken.value( QOAuth::ParamToken ); tokenSecret = accessToken.value( QOAuth::ParamTokenSecret ); state = true; accept(); }
int restful_rhizome_insert(httpd_request *r, const char *remainder) { r->http.response.header.content_type = CONTENT_TYPE_JSON; if (*remainder) return 404; if (!is_rhizome_http_enabled()) return 403; if (r->http.verb != HTTP_VERB_POST) return 405; int ret = authorize(&r->http); if (ret) return ret; // Parse the request body as multipart/form-data. assert(r->u.insert.current_part == NULL); assert(!r->u.insert.received_author); assert(!r->u.insert.received_secret); assert(!r->u.insert.received_manifest); assert(!r->u.insert.received_payload); bzero(&r->u.insert.write, sizeof r->u.insert.write); r->u.insert.write.blob_fd = -1; r->finalise_union = finalise_union_rhizome_insert; r->http.form_data.handle_mime_part_start = insert_mime_part_start; r->http.form_data.handle_mime_part_end = insert_mime_part_end; r->http.form_data.handle_mime_part_header = insert_mime_part_header; r->http.form_data.handle_mime_body = insert_mime_part_body; // Perform the insert once the body has arrived. r->http.handle_content_end = restful_rhizome_insert_end; return 1; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); connectionManager = new QTcpSocket(this); form = new ChatBoxDialog(0); createdTabs = new QMap<QString, ChatBoxDialogContent*>; createStatusBar(); createTrayIcon(); openLocalDatabase(); loadMyProfile(); initContactsList(); this->settings = new QSettings("settings.ini", QSettings::IniFormat); QString hostname = this->settings->value("Server/Hostname").toString(); int port = this->settings->value("Server/Port").toInt(); connect(this->connectionManager, SIGNAL(connected()), this, SLOT(authorize())); connectToServer(hostname, port); }
void main (int argc, char *argu[]) { char *name, *pass; size_t n; int ii; name = "root"; for (ii = 1; ii < argc; ii++) { if (argu[ii][0] != '-' || argu[ii][1] == 0) break; if (argu[ii][1] == '-' && argu[ii][2] == 0) { ii++; break; } switch (argu[ii][1]) { case 'u': name = argu[++ii]; break; default: errx (1, "bad option %c", argu[ii][1]); } } if (ii > argc) errx (1, "bad arguments"); pass = getpass ("Password: "******"Denied\n", stdout); errx (1, "authorization failed"); }
//ダイアログの実行開始 int TweetDialog::exec() { //認証済みか確認 authorize(); //ハッシュタグ return QDialog::exec(); }
/** \brief This function actually does an Authorization then a Charge Preauth. Changes don't occurr real-time so we do the preauth real-time and if that succeeds just put the record in the correct state to be charged later. If the processor can't do the charge then the transaction must be undone. */ int PaymentechProcessor::doCharge(const int pccardid, const int pcvv, const double pamount, const double ptax, const bool ptaxexempt, const double pfreight, const double pduty, const int pcurrid, QString& pneworder, QString& preforder, int &pccpayid, ParameterList &pparams) { if (DEBUG) qDebug("Paymentech:doCharge(%d, %d, %f, %f, %d, %f, %f, %d, %s, %s, %d)", pccardid, pcvv, pamount, ptax, ptaxexempt, pfreight, pduty, pcurrid, pneworder.toAscii().data(), preforder.toAscii().data(), pccpayid); int returnValue = 0; int refid = 0; returnValue = authorize(pccardid, pcvv, pamount, ptax, ptaxexempt, pfreight, pduty, pcurrid, pneworder, preforder, pccpayid, "", refid); /* don't return here because the caller is going to need all of the parameter data if(returnValue < 0) { return returnValue; } */ double amount = pamount; int currid = pcurrid; XSqlQuery ccq; ccq.prepare("SELECT ccpay_r_avs, ccpay_r_ordernum, ccpay_r_error," " ccpay_r_code, ccpay_r_shipping, ccpay_r_tax," " ccpay_r_ref, ccpay_r_message, ccpay_yp_r_tdate" " FROM ccpay" " WHERE(ccpay_id=:ccpayid);"); ccq.bindValue(":ccpayid", pccpayid); ccq.exec(); if(!ccq.first()) { return -1; } pparams.append("ccard_id", pccardid); pparams.append("currid", currid); pparams.append("auth_charge", "C"); pparams.append("type", "C"); pparams.append("status", "C"); pparams.append("reforder", (preforder.isEmpty()) ? pneworder : preforder); pparams.append("ordernum", pneworder); pparams.append("approved", "SUBMITTED"); pparams.append("avs", ccq.value("ccpay_r_avs").toString()); pparams.append("xactionid", ccq.value("ccpay_r_ordernum").toString()); pparams.append("error", ccq.value("ccpay_r_error").toString()); pparams.append("code", ccq.value("ccpay_r_code").toString()); pparams.append("shipping", ccq.value("ccpay_r_shipping").toString()); pparams.append("tax", ccq.value("ccpay_r_tax").toString()); pparams.append("ref", ccq.value("ccpay_r_ref").toString()); pparams.append("message", ccq.value("ccpay_r_message").toString()); pparams.append("tdate", ccq.value("ccpay_yp_r_tdate").toString()); pparams.append("auth", false); pparams.append("amount", amount); return returnValue; }
static int is_authorized_for_put(struct mg_connection *conn) { const char *passfile = conn->ctx->config[PUT_DELETE_PASSWORDS_FILE]; FILE *fp; int ret = 0; if (passfile != NULL && (fp = mg_fopen(passfile, "r")) != NULL) { ret = authorize(conn, fp); fclose(fp); } return ret; }
void Server::event_handler(struct mg_connection *conn, int ev, void *p) { struct http_message *hm = (struct http_message *) p; if (ev == MG_EV_SSI_CALL) { mbuf_resize(&conn->send_mbuf, conn->send_mbuf.size * 2); std::string resp(conn->send_mbuf.buf, conn->send_mbuf.len); boost::replace_all(resp, "href=\"/", std::string("href=\"") + CONFIG_STRING(m_config, "service.base_location")); boost::replace_all(resp, "src=\"/", std::string("src=\"") + CONFIG_STRING(m_config, "service.base_location")); boost::replace_all(resp, "action=\"/", std::string("action=\"") + CONFIG_STRING(m_config, "service.base_location")); strcpy(conn->send_mbuf.buf, resp.c_str()); mbuf_trim(&conn->send_mbuf); return; } if (ev != MG_EV_HTTP_REQUEST) { return; } hm->uri.p += CONFIG_STRING(m_config, "service.base_location").size() - 1; hm->uri.len -= CONFIG_STRING(m_config, "service.base_location").size() - 1; if (!is_authorized(conn, hm)) { redirect_to(conn, hm, "/login"); } else if (mg_vcmp(&hm->uri, "/authorize") == 0) { authorize(conn, hm); } else if (mg_vcmp(&hm->uri, "/logout") == 0) { serve_logout(conn, hm); // } else if (mg_vcmp(&hm->uri, "/users") == 0) { // serve_users(conn, hm); // } else if (mg_vcmp(&hm->uri, "/users/add") == 0) { // serve_users_add(conn, hm); // } else if (mg_vcmp(&hm->uri, "/users/remove") == 0) { // serve_users_remove(conn, hm); } else if (has_prefix(&hm->uri, "/oauth2")) { serve_oauth2(conn, hm); } else if (has_prefix(&hm->uri, "/api/v1/")) { m_apiServer->handleRequest(this, get_session(hm), conn, hm); } else { if (hm->uri.p[hm->uri.len - 1] != '/') { std::string url(hm->uri.p, hm->uri.len); if (url.find(".") == std::string::npos) { url += "/"; redirect_to(conn, hm, url.c_str()); conn->flags |= MG_F_SEND_AND_CLOSE; return; } } mg_serve_http(conn, hm, s_http_server_opts); } conn->flags |= MG_F_SEND_AND_CLOSE; }
int onion_handler_auth_pam_handler(onion_handler_auth_pam_data *d, onion_request *request, onion_response *res){ /// Use session to know if already logged in, so do not mess with PAM so often. if (onion_request_get_session(request, "pam_logged_in")) return onion_handler_handle(d->inside, request, res); const char *o=onion_request_get_header(request, "Authorization"); char *auth=NULL; char *username=NULL; char *passwd=NULL; if (o && strncmp(o,"Basic",5)==0){ //fprintf(stderr,"auth: '%s'\n",&o[6]); auth=onion_base64_decode(&o[6], NULL); username=auth; int i=0; while (auth[i]!='\0' && auth[i]!=':') i++; if (auth[i]==':'){ auth[i]='\0'; // so i have user ready passwd=&auth[i+1]; } else passwd=NULL; } // I have my data, try to authorize if (username && passwd){ int ok=authorize(d->pamname, username, passwd); if (ok){ // I save the username at the session, so it can be accessed later. onion_dict *session=onion_request_get_session_dict(request); onion_dict_lock_write(session); onion_dict_add(session, "username", username, OD_REPLACE|OD_DUP_VALUE); onion_dict_add(session, "pam_logged_in", username, OD_REPLACE|OD_DUP_VALUE); onion_dict_unlock(session); free(auth); return onion_handler_handle(d->inside, request, res); } } if (auth) free(auth); // Not authorized. Ask for it. char temp[256]; sprintf(temp, "Basic realm=\"%s\"",d->realm); onion_response_set_header(res, "WWW-Authenticate",temp); onion_response_set_code(res, HTTP_UNAUTHORIZED); onion_response_set_length(res,sizeof(RESPONSE_UNAUTHORIZED)); onion_response_write(res,RESPONSE_UNAUTHORIZED,sizeof(RESPONSE_UNAUTHORIZED)); return OCS_PROCESSED; }
void OAuthWizard::openUrl() { QOAuth::ParamMap requestToken = qoauth->requestToken( TwitterRequestTokenURL, QOAuth::GET, QOAuth::HMAC_SHA1 ); if ( qoauth->error() != QOAuth::NoError ) { if ( sender() == ui_p->okButton ) { delete ui_o->widget->layout(); ui_p->okButton->deleteLater(); ui_p->pinEdit->deleteLater(); ui_p->pinLabel->deleteLater(); ui_a->setupUi(ui_o->widget); } ui_a->allowLabel->setText( tr( "There was a network-related problem with completing the request. Please try again later." ) ); ui_a->allowButton->setText( tr( "Retry" ) ); adjustSize(); resize( width(), height() * 1.5 ); state = false; return; } token = requestToken.value( QOAuth::ParamToken ); tokenSecret = requestToken.value( QOAuth::ParamTokenSecret ); QString url = TwitterAuthorizeURL; url.append( "?" ); url.append( "&" + QOAuth::ParamToken + "=" + token ); url.append( "&" + ParamCallback + "=" + ParamCallbackValue ); QDesktopServices::openUrl( QUrl( url ) ); delete ui_o->widget->layout(); if ( sender() == ui_p->okButton ) { delete ui_o->widget->layout(); ui_p->okButton->deleteLater(); ui_p->pinEdit->deleteLater(); ui_p->pinLabel->deleteLater(); } else { ui_a->allowLabel->deleteLater(); ui_a->allowButton->deleteLater(); } ui_p->setupUi(ui_o->widget); ui_p->pinEdit->setValidator( new QRegExpValidator( QRegExp( "\\d{6}" ), this ) ); connect( ui_p->okButton, SIGNAL(clicked()), this, SLOT(authorize()) ); connect( ui_p->pinEdit, SIGNAL(textChanged(QString)), this, SLOT(setOkButtonEnabled()) ); }
static json_object * get_cached(const char *url, const char *name) { char fname[PATH_MAX]; char full_url[500]; int rc = 0; const char *error; json_object *root; snprintf(fname, PATH_MAX-1, "%s%s.json", cache_path, name); if (expired(fname, 3600*24)) { get_full_url(url, full_url); rc = fetch(full_url, fname); } if (rc != 0) { provider->error_number = 1; return NULL; } root = json_object_from_file(fname); error = get_str(root, "error"); if (rc == 0 && root != NULL && error == NULL) return root; sleep(2); authorize(NULL); get_full_url(url, full_url); rc = fetch(url, fname); root = json_object_from_file(fname); error = get_str(root, "error"); if (rc != 0 || root == NULL) { sprintf(last_error, "cannot load %s. rc: %d", fname, rc); provider->error_number = 1; return NULL; } if (error != NULL) { remove(fname); sprintf(last_error, "api error: %s", error); provider->error_number = 1; return NULL; } return root; }
int XttVideoMgmAimetis::check_session() { pwr_tTime current; pwr_tDeltaTime timeout = {300,0}; pwr_tDeltaTime dt; int sts = 1; // Check that current session hasn't timed out time_GetTime( ¤t); time_Adiff_NE( &dt, ¤t, &m_last_auth); if ( time_Dcomp( &dt, &timeout) == 1) sts = authorize( m_op->User, m_op->Password); return sts; }
void authorize(const Response &challenge, Request &nextRequest, const std::string &username, const std::string &password) { MORDOR_ASSERT(challenge.status.status == UNAUTHORIZED || challenge.status.status == PROXY_AUTHENTICATION_REQUIRED); bool proxy = challenge.status.status == PROXY_AUTHENTICATION_REQUIRED; const ChallengeList &authenticate = proxy ? challenge.response.proxyAuthenticate : challenge.response.wwwAuthenticate; AuthParams &authorization = proxy ? nextRequest.request.proxyAuthorization : nextRequest.request.authorization; authorize(challengeForSchemeAndRealm(authenticate, "Digest"), authorization, nextRequest.requestLine.uri, nextRequest.requestLine.method, username, password); }
grpc::Status implement_status(Authorize &&authorize, F &&f) { try { const grpc::Status auth = authorize(); if (!auth.ok()) return auth; } catch (std::exception &e) { return grpc::Status(grpc::UNKNOWN, "Unable to authorize"); } catch (...) { return grpc::Status(grpc::UNKNOWN, "Unable to authorize"); } try { return f(); } catch (std::exception &e) { return grpc::Status(grpc::UNKNOWN, e.what()); } catch (...) { return grpc::Status(grpc::UNKNOWN, "Unknown"); } }
int restful_rhizome_bundlelist_json(httpd_request *r, const char *remainder) { r->http.response.header.content_type = CONTENT_TYPE_JSON; if (!is_rhizome_http_enabled()) return 403; if (*remainder) return 404; if (r->http.verb != HTTP_VERB_GET) return 405; int ret = authorize(&r->http); if (ret) return ret; r->u.rhlist.phase = LIST_HEADER; r->u.rhlist.rowcount = 0; bzero(&r->u.rhlist.cursor, sizeof r->u.rhlist.cursor); http_request_response_generated(&r->http, 200, CONTENT_TYPE_JSON, restful_rhizome_bundlelist_json_content); return 1; }
void MainServer::parseData( const QString& cmd, int clientId ) { Clients::iterator i = clients.find( clientId ); if( i == clients.end() ) return; if( authorize( cmd, i ) ) return; if( setField( cmd, i ) ) return; if( makeStep( cmd, i ) ) return; i->send( "wrongcmd:" ); }
int XttVideoMgmAimetis::init() { int sts; sts = authorize( m_op->User, m_op->Password); if ( EVEN(sts)) return sts; sts = get_panels(); if ( EVEN(sts)) return sts; sts = get_cameras(); if ( EVEN(sts)) return sts; // Set default panel sts = display_panel( m_op->DefaultPanel); m_op->PanelArraySelect[m_op->DefaultPanel] = 1; m_panel_select_old[m_op->DefaultPanel] = 1; return 1; }
int restful_rhizome_(httpd_request *r, const char *remainder) { r->http.response.header.content_type = CONTENT_TYPE_JSON; if (!is_rhizome_http_enabled()) return 403; HTTP_HANDLER *handler = NULL; rhizome_bid_t bid; const char *end; if (strn_to_rhizome_bid_t(&bid, remainder, &end) != -1) { if (strcmp(end, ".rhm") == 0) { handler = restful_rhizome_bid_rhm; remainder = ""; } else if (strcmp(end, "/raw.bin") == 0) { handler = restful_rhizome_bid_raw_bin; remainder = ""; } else if (strcmp(end, "/decrypted.bin") == 0) { handler = restful_rhizome_bid_decrypted_bin; remainder = ""; } } if (handler == NULL) return 404; if (r->http.verb != HTTP_VERB_GET) return 405; int ret = authorize(&r->http); if (ret) return ret; if ((r->manifest = rhizome_new_manifest()) == NULL) return 500; ret = rhizome_retrieve_manifest(&bid, r->manifest); if (ret == -1) return 500; if (ret == 0) { rhizome_authenticate_author(r->manifest); r->http.render_extra_headers = render_manifest_headers; } else { assert(r->manifest == NULL); assert(r->http.render_extra_headers == NULL); } ret = handler(r, remainder); return ret; }
static int begin_request_handler(struct mg_connection *conn) { const struct mg_request_info *request_info = mg_get_request_info(conn); int processed = 1; if (!request_info->is_ssl) { redirect_to_ssl(conn, request_info); } else if (!is_authorized(conn, request_info)) { redirect_to_login(conn, request_info); } else if (strcmp(request_info->uri, authorize_url) == 0) { authorize(conn, request_info); } else if (strcmp(request_info->uri, "/ajax/get_messages") == 0) { ajax_get_messages(conn, request_info); } else if (strcmp(request_info->uri, "/ajax/send_message") == 0) { ajax_send_message(conn, request_info); } else { // No suitable handler found, mark as not processed. Civetweb will // try to serve the request. processed = 0; } return processed; }
void main (int argc, char *argu[]) { char *pass; int ii; for (ii = 1; ii < argc; ii++) { if (argu[ii][0] != '-' || argu[ii][1] == 0) break; if (argu[ii][1] == '-' && argu[ii][2] == 0) { ii++; break; } } if (ii >= argc) errx (1, "no name given"); pass = getpass ("Password: "******"Denied\n", stdout); errx (1, "authorization failed"); }
Command::Status open(std::string hostname, int port, Context &context) { *context.output << "Open connection to \"" << hostname << ":" << port << "\"" << std::endl; context.ftp.open(hostname, port); context.ftp.readInto(*context.output); Command::Status authResult = authorize(context); if (authResult != OK) { return authResult; } std::stringstream currDirStream; if (!context.ftp.pwd(currDirStream)) { return ERROR; } int pwd_code; currDirStream >> pwd_code; currDirStream >> context.workingDirectory; return OK; }
int main( int argc, char** argv ) { BApplication* pcApp = new BApplication( "application/x-vnd.KHS-desktop_manager" ); #if 0 if( getuid() == 0 ) { const char* pzLoginName = NULL; if ( argc == 2 ) { pzLoginName = argv[1]; } authorize( pzLoginName ); } #endif const char* pzBaseDir = getenv( "COSMOE_SYS" ); if( pzBaseDir == NULL ) { pzBaseDir = "/cosmoe"; } char* pzPath = new char[ strlen(pzBaseDir) + 80 ]; strcpy( pzPath, pzBaseDir ); strcat( pzPath, "/backdrop.jpg" ); g_pcBackDrop = load_jpeg( pzPath ); delete[] pzPath; BWindow* pcBitmapWindow = new BWindow( BRect( 0, 0, 1599, 1199 ), "", B_NO_BORDER_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL, WND_BACKMOST, B_ALL_WORKSPACES ); pcBitmapWindow->AddChild( new BitmapView( BRect( 0, 0, 1599, 1199 ), g_pcBackDrop ) ); pcBitmapWindow->Show(); pcApp->Run(); return( 0 ); }
int restful_rhizome_newsince(httpd_request *r, const char *remainder) { r->http.response.header.content_type = CONTENT_TYPE_JSON; if (!is_rhizome_http_enabled()) return 403; uint64_t rowid; const char *end = NULL; if (!strn_to_list_token(remainder, &rowid, &end) || strcmp(end, "/bundlelist.json") != 0) return 404; if (r->http.verb != HTTP_VERB_GET) return 405; int ret = authorize(&r->http); if (ret) return ret; r->u.rhlist.phase = LIST_HEADER; r->u.rhlist.rowcount = 0; bzero(&r->u.rhlist.cursor, sizeof r->u.rhlist.cursor); r->u.rhlist.cursor.rowid_since = rowid; r->u.rhlist.end_time = gettime_ms() + config.rhizome.api.restful.newsince_timeout * 1000; http_request_response_generated(&r->http, 200, CONTENT_TYPE_JSON, restful_rhizome_bundlelist_json_content); return 1; }
bool S3::upload(std::string pathToImage) { std::vector<std::string> headers; // File name std::vector<std::string> tokens; helper::tokenize(pathToImage, tokens, "/"); std::string fileName = helper::urlencode(tokens[tokens.size()-1]); // Host URL headers.push_back("Host: " + m_bucket + ".s3.amazonaws.com"); // Date std::string date = getDate(); headers.push_back("Date: " + date); // folder std::string folder = (m_folder == "") ? "" : m_folder + "/"; // Authorize request std::string request = "PUT\n"; request += "\n"; request += "\n"; request += date + "\n"; request += "/" + m_bucket + "/" + folder + fileName; headers.push_back("Authorization: " + authorize(request)); // Url std::string url = "https://" + m_bucket + ".s3.amazonaws.com/" + folder + fileName; // Body std::vector<std::string> body; body.push_back(pathToImage); // Execute get operation return put(url, headers, body); }
/* * Authorize using WWW-Authorize header field */ int aaa_www_authorize(struct sip_msg* _msg, char* _realm, char* _uri_user) { return authorize(_msg, (pv_elem_t*)_realm, (pv_spec_t *)_uri_user, HDR_AUTHORIZATION_T); }
/* * Authorize using Proxy-Authorize header field (URI user parameter given) */ int aaa_proxy_authorize_2(struct sip_msg* _msg, char* _realm, char* _uri_user) { return authorize(_msg, (pv_elem_t*)_realm, (pv_spec_t *)_uri_user, HDR_PROXYAUTH_T); }
/* * Authorize using Proxy-Authorize header field (no URI user parameter given) */ int aaa_proxy_authorize_1(struct sip_msg* _msg, char* _realm, char* _s2) { /* realm parameter is converted in fixup */ return authorize(_msg, (pv_elem_t*)_realm, (pv_spec_t *)0, HDR_PROXYAUTH_T); }