void Server::authorize(struct mg_connection *conn, struct http_message *hm) { Server::session *session; std::string user = get_http_var(hm, "user"); std::string password = get_http_var(hm, "password"); std::string host; mg_str *host_hdr = mg_get_http_header(hm, "Host"); if (host_hdr) { if (!CONFIG_STRING(m_config, "service.cert").empty()) { host += "https://"; } else { host += "http://"; } host += std::string(host_hdr->p, host_hdr->len); } if (check_password(user, password) && (session = new_session(user)) != NULL) { std::cout << "User authorized\n"; mg_printf(conn, "HTTP/1.1 302 Found\r\n" "Set-Cookie: session=%s; max-age=3600; http-only\r\n" // Session ID "Set-Cookie: user=%s\r\n" // Set user, needed by Javascript code "Set-Cookie: admin=%s\r\n" // Set user, needed by Javascript code "Set-Cookie: base_location=%s\r\n" // Set user, needed by Javascript code "Set-Cookie: original_url=/; max-age=0\r\n" // Delete original_url "Location: %s%sinstances\r\n\r\n", session->session_id, session->user, session->admin ? "1" : "0", CONFIG_STRING(m_config, "service.base_location").c_str(), host.c_str(), CONFIG_STRING(m_config, "service.base_location").c_str()); } else { // Authentication failure, redirect to login. redirect_to(conn, hm, "/login"); } }
int RASocket::authenticate() { if (send(std::string("Username: "******"Password: "******"Login attempt for user: %s", user.c_str()); if (check_access_level(user) == -1) return -1; if (check_password(user, pass) == -1) return -1; sLog->outRemote("User login: %s", user.c_str()); return 0; }
int main(int argc, const char **argv) { jaro_credential_t cred = {0}; int res = 0; if (argc < 2) { error("Usage: jaro-gnome-keyring <get|check|store|erase>"); error("input from stdin: newline separated parameter=value tuples"); error("i.e: protocol, path, username, host, password (password on store)"); return 1; } if (read_credential(&cred)) { clear_credential(&cred); return 1; } if (strcmp(argv[1], "get") == 0) { res = get_password(&cred); } if (strcmp(argv[1], "check") == 0) { res = check_password(&cred); } else if (strcmp(argv[1], "store") == 0) { res = store_password(&cred); } else if (strcmp(argv[1], "erase") == 0) { res = erase_password(&cred); } clear_credential(&cred); return res; }
/* Authenticates the user, returns 0 on success, 1 on fail */ static int check_auth() { struct passwd *pw; uid_t uid; #ifdef HAVE_AUDIT uid = audit_getloginuid(); if (uid == (uid_t) -1) uid = getuid(); #else uid = getuid(); #endif pw = getpwuid(uid); if (!pw) { eerror("cannot find your entry in the passwd file."); return (-1); } printf("Authenticating %s.\n", pw->pw_name); /* do the actual check */ if (check_password(pw->pw_name) == 0) { return 0; } eerrorx("Authentication failed for %s", pw->pw_name); return 1; }
int create_account(DB *database, unsigned char *username, unsigned char *password) { int user_hash = SearchHash(username); if (!strcmp(username, database->db[user_hash].username)) { printf("Sorry, that username is already taken. Please try again.\n\n"); return 0; } if (!check_password(password)) { printf("Sorry, your password must be 8-20 characters in length and contain "); printf("either a number or one of these special characters: !@#$%%*.\n\n"); return 0; } // copy username to db location strcpy(database->db[user_hash].username, username); // create new password with salt int new_length = strlen(password) + strlen(salt); char *salt_password = malloc(sizeof(char) * new_length + 1); strcpy(salt_password, password); strcat(salt_password, salt); database->db[user_hash].password = CryptoHash(salt_password); return 1; }
//main function for running program int main() { bool is_permission = false; int attempt_number = 1; char password[] = PASSWORD; char password_attempt[100]; print_intro(); //password attempt loop do { print_security_level(attempt_number); scanf("%99s", password_attempt); is_permission = check_password(password, password_attempt); //print cases for password attempt if(is_permission == false && attempt_number == MAX_ATTEMPT) { print_password_denied(attempt_number, MAX_ATTEMPT); system("qlmanage -p ./data/ned.gif"); animate(); } else if(is_permission == true) print_access(); else { print_password_denied(attempt_number, MAX_ATTEMPT); attempt_number++; } }while(is_permission == false); return 0; }
int RASocket::authenticate() { if (send(std::string("Username: "******"Password: "******"Login attempt for user: %s", user.c_str()); if (check_access_level(user) == -1) return -1; if (check_password(user, pass) == -1) return -1; TC_LOG_INFO(LOG_FILTER_REMOTECOMMAND, "User login: %s", user.c_str()); return 0; }
int check_restriction(long idx_article) { int fd; int len; char restriction_pass2[20]; SHA1Context sha; char title[MAX_TITLE_ACTUAL]; init_filtering = 0; if (restriction_filter_off == -1) { fd = wl_open("wiki.pas", WL_O_RDONLY); if (fd >= 0) { len = wl_read(fd, restriction_pass1, 20); if (len < 20) memset(restriction_pass1, 0, 20); memset(restriction_pass2, 0, 20); if (memcmp(restriction_pass1, restriction_pass2, 20)) // all 0's for no password saved { len = wl_read(fd, restriction_pass2, 20); if (len < 20) memset(restriction_pass2, 0, 20); SHA1Reset(&sha); SHA1Input(&sha, (const unsigned char *) restriction_pass1, 20); SHA1Result(&sha); if (!memcmp(sha.Message_Digest, restriction_pass2, 20)) restriction_filter_off = 1; else restriction_filter_off = 0; } wl_close(fd); } } if (restriction_filter_off == -1) { get_article_title_from_idx(saved_idx_article, title); memset(&framebuffer[0], 0, (BLACK_SPACE_START - 1)* LCD_VRAM_WIDTH_PIXELS / 8); render_string(TITLE_FONT_IDX, LCD_LEFT_MARGIN, LCD_TOP_MARGIN, title, strlen(title), 0); first_time_password(0); return -1; } else if (restriction_filter_off) return 0; // ok else { get_article_title_from_idx(saved_idx_article, title); memset(&framebuffer[0], 0, (BLACK_SPACE_START - 1)* LCD_VRAM_WIDTH_PIXELS / 8); render_string(TITLE_FONT_IDX, LCD_LEFT_MARGIN, LCD_TOP_MARGIN, title, strlen(title), 0); password_str_len = 0; check_password(); return -1; } }
/** * Parse username and password */ static int parse_auth(SSH *ssh) { byte *p; byte *out; byte aux; word32 outSz; p = ssh->sp.data; /* Get username */ read_bin(&p, &out, &outSz); /* Size valid? */ if (outSz > MAX_UN_LEN) return -1; memcpy(ssh->user, out, outSz); ssh->user[outSz] = 0; /* Get service */ read_bin(&p, &out, &outSz); /* Get method */ read_bin(&p, &out, &outSz); /* Only support password based autentication */ if (memcmp(out, PASSWORD_STR, strlen(PASSWORD_STR)) != 0) { return 1; } /* Read byte */ read_byte(&p, &aux); /* Get password */ read_bin(&p, &out, &outSz); /* Size valid? */ if (outSz > MAX_PW_LEN) return -1; memcpy(ssh->pass, out, outSz); ssh->pass[outSz] = 0; /* Check username and password */ if (check_password(ssh->user, ssh->pass) < 0) { /* Limit auth attempts */ if (ssh->authAtt++ > 1) { return -1; } return 1; } ssh->state = SSH_AUTH; return 0; }
int main(int argc, char *argv[]){ if(argc >= 2){ if(check_password(argv[1])){ printf("%s", "Access granted\n"); }else{ printf("%s", "Access denied\n"); } }else{ printf("%s", "Please enter password!\n"); } }
/*************************************************************************** Function: cgiMain Description: Input: Output: Return: 0 OK, other Error Others: none ***************************************************************************/ int cgiMain() { char account[FEATURE_GDGL_ACCOUNT_MAX_LEN + 1]; //16 + terminating null char password[FEATURE_GDGL_PASSWD_MAX_LEN + 1]; //16 + terminating null char gateway_id[FEATURE_GDGL_ID_LEN + 1]; //12 + terminating null char gateway_alias[FEATURE_GDGL_ACCOUNT_MAX_LEN + 1]; char gateway_passwd[FEATURE_GDGL_PASSWD_MAX_LEN + 1]; cgiFormResultType cgi_re; int res; cgiHeaderContentType("application/json"); //MIME // Read ID res = read_id(gateway_id); if (res != 0) { client_admin_response("noid", res, clientAdminResultStr[res]); return res; } // Read alias res = read_alias(gateway_alias); if (res != 0) { client_admin_response(gateway_id, res, clientAdminResultStr[res]); return res; } // Read password res = read_password(gateway_passwd); if (res != 0) { client_admin_response(gateway_id, res, clientAdminResultStr[res]); return res; } // Check account cgi_re = cgiFormString("account", account, FEATURE_GDGL_ACCOUNT_MAX_LEN + 1); res = check_account(cgi_re, account, gateway_id, gateway_alias); if (res != 0) { client_admin_response(gateway_id, res, clientAdminResultStr[res]); return res; } // Check password cgi_re = cgiFormString("password", password, FEATURE_GDGL_PASSWD_MAX_LEN + 1); res = check_password(cgi_re, password, gateway_passwd); if (res != 0) { client_admin_response(gateway_id, res, clientAdminResultStr[res]); return res; } // account & password all right client_admin_response(gateway_id, clientAdminSuccess, clientAdminResultStr[clientAdminSuccess]); return 0; }
int pam_multipass_authenticate(json_object *hashes, const char *password) { int ret = PAM_AUTH_ERR; json_object_object_foreach(hashes, name, obj) { const char *hash = json_object_get_string(json_object_object_get(obj, "hash")); if (hash == NULL) { fprintf(stderr, "pam_multipass: no hash defined for %s\n", name); } ret = check_password(password, hash); if (ret == 0) break; } return ret; }
int main(){ char buf[BUFSIZE]; // Read until newline fwrite("Enter the secret password: "******"Yay, your token is: %s\n", TOKEN); } else { printf("Wrong password!\n"); } return 0; }
void work(int newsockfd, struct sockaddr_in cli_addr) { if (newsockfd < 0) { FM_LOG_WARNING("ERROR on accept"); return; } FM_LOG_NOTICE("connect from %s:%d", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port)); char buffer[BUFF_SIZE]; bzero(buffer, BUFF_SIZE); ssize_t n = read(newsockfd, buffer, BUFF_SIZE); if (n < 0) FM_LOG_WARNING("ERROR reading from socket"); FM_LOG_NOTICE("Here is the password: %s", buffer); if (check_password(oj_config.password, buffer)) { FM_LOG_DEBUG("Authentication Ok."); n = write(newsockfd, "Authentication Ok.", 18); if (n < 0) FM_LOG_WARNING("ERROR writing to socket"); bzero(buffer, BUFF_SIZE); n = read(newsockfd, buffer, BUFF_SIZE); if (n <= 0) { FM_LOG_WARNING("ERROR reading from socket"); close(newsockfd); return; } FM_LOG_NOTICE("Here is the message: %s(%d)", buffer, n); oj_solution_t oj_solution{}; if (parse_arguments(buffer, oj_solution) < 0) { FM_LOG_WARNING("Missing some parameters."); n = write(newsockfd, "Missing some parameters.", 24); if (n < 0) FM_LOG_WARNING("ERROR writing to socket"); close(newsockfd); return; } else { n = write(newsockfd, "I got your request.", 19); if (n < 0) FM_LOG_WARNING("ERROR writing to socket"); close(newsockfd); ProcessQueue.push(oj_solution); return; } } else { FM_LOG_WARNING("Authentication Failed."); n = write(newsockfd, "Authentication Failed.", 22); if (n < 0) FM_LOG_WARNING("ERROR writing to socket"); } close(newsockfd); }
void do_password(dbref player, const char *old, const char *newobj) { if (!check_password(player, old)) { notify(player, "Sorry"); } else if (!ok_password(newobj)) { notify(player, "Bad new password."); } else { set_password(player, newobj); notify(player, "Password changed."); } }
int main(void) { int pass = 0; printf("Enter the pin: "); pass = check_password(); if (!pass) { puts("Access denied"); return 1; } /* now give root privelege */ puts("Correct pin! You are the root!"); puts("Let do something fun!"); return 0; }
int cgiMain() { int sensor_num,sensor_idx; int i,j,k; char name[81]; light_sensor *p_sensor ; cgiFormInteger("sensor_num", &sensor_num, 0); if(sensor_num > 100) sensor_num = 100; cgiWriteEnvironment("/CHANGE/THIS/PATH/capcgi.dat"); cgiHeaderContentType("text/html"); OutHead(); OutBodyStart(); if(0 == check_password()) return 0; if(0 == sensor_num) { fprintf(cgiOut, "<p>数据出错,退出!!</p>\n"); OutBodyEnd(); return 0; } else { pwsw_h.sensor_num= sensor_num; for(i=0;i<sensor_num;i++) { p_sensor = &pwsw_h.sensor[i]; p_sensor->lux = get_lux(i+1); p_sensor->voltage = get_voltage(i+1); } } save_to_xml_file(); fprintf(cgiOut, "<p>保存成功,请返回!</p>\n"); fprintf(cgiOut, " <input type=\"button\" name=\"rest\" onclick=\"javascript:history.go(-1)\" value=\"重新载入\" />\n"); OutBodyEnd(); return 0; }
/* auth_flatfile_new_user_pass: * Attempt to authenticate user and pass using an alternate passwd file, * as configured at compile-time. This is a virtual-domains authenticator. */ authcontext auth_flatfile_new_user_pass(const char *user, const char *local_part, const char *domain, const char *pass, const char *clienthost /* unused */, const char *serverhost /* unused */) { authcontext a = NULL; char *pwhash, *who; if (!local_part) return NULL; who = username_string(user, local_part, domain); pwhash = read_user_passwd(local_part, domain); if (pwhash) { if (check_password(who, pwhash, pass, "{crypt}")) a = authcontext_new(virtual_uid, virtual_gid, NULL, NULL, NULL); else log_print(LOG_ERR, _("auth_flatfile_new_user_pass: failed login for %s"), who); } return a; }
int main(int argc, char* argv[]){ if(argc<2){ printf("usage : %s [passcode]\n", argv[0]); return 0; } if(strlen(argv[1]) != 20){ printf("passcode length should be 20 bytes\n"); return 0; } if(hashcode == check_password( argv[1] )){ system("/bin/cat flag"); return 0; } else printf("wrong passcode.\n"); return 0; }
void do_password(dbref player, const char *old, const char *newobj) { if (Guest(player)) { anotify_fmt(player, CFAIL "%s", tp_noguest_mesg); return; } if (!check_password(player, old)) { anotify_nolisten2(player, CFAIL "Syntax: @password <oldpass>=<newpass>"); } else if (!ok_password(newobj)) { anotify_nolisten2(player, CFAIL "Bad new password."); } else { set_password(player, newobj); anotify_nolisten2(player, CFAIL "Password changed."); } }
static const char *ircservices_crypt_string(const char *key, const char *salt) { static char output[PASSMAX]; if (salt[0] == '$' && salt[1] == '1') /* this is a new pw XXX */ { myencrypt(key, strlen(key), output, PASSMAX); return output; } else { if (check_password(key, salt)) return salt; else { output[0] = '\0'; return output; } } }
boost::tuple<shared_data::action, client_info> shared_data::process_user(const std::string& uname, const std::string& phash, int session_id) { boost::mutex::scoped_lock lock(guard_); // XXX Get password from database. // if(lookup_username_in_database_fails) { // return boost::make_tuple(user_not_found, it->second); // } auto it = clients_.find(uname); if(session_id == -1) { // No session id, check if user name in list already. if(it == clients_.end()) { // User name not in list. Let's add it. auto ret = clients_.insert(std::pair<std::string, client_info>(uname, client_info(generate_session_id(), true, generate_salt()))); it = ret.first; } } else { if(it == clients_.end()) { // user not in list, but we've got a session id. Expire session and generate a new id. auto ret = clients_.insert(std::pair<std::string, client_info>(uname, client_info(generate_session_id(), true, generate_salt()))); it = ret.first; } else { // We have been sent a session_id, check if it's valid. if(it->second.session_id != session_id) { it->second.signed_in = false; return boost::make_tuple(bad_session_id, it->second); } } } if(phash.empty()) { return boost::make_tuple(send_salt, it->second); } else { if(check_password(it->second.salt, fixed_password, phash)) { it->second.signed_in = true; return boost::make_tuple(login_success, it->second); } else { it->second.signed_in = false; return boost::make_tuple(password_failed, it->second); } } }
dbref connect_player(const char *name, const char *password) { dbref player; if (*name == NUMBER_TOKEN && number(name + 1) && atoi(name + 1)) { player = (dbref) atoi(name + 1); if ((player < 0) || (player >= db_top) || (Typeof(player) != TYPE_PLAYER)) player = NOTHING; } else { player = lookup_player(name); } if (player == NOTHING) return NOTHING; if (!check_password(player, password)) return NOTHING; return player; }
bool ladmin_auth(struct login_session_data* sd, const char* ip) { bool result = false; if( str2ip(ip) != host2ip(login_config.admin_allowed_host) ) ShowNotice("'ladmin'-login: Connection in administration mode REFUSED - IP isn't authorised (ip: %s).\n", ip); else if( !login_config.admin_state ) ShowNotice("'ladmin'-login: Connection in administration mode REFUSED - remote administration is disabled (ip: %s)\n", ip); else if( !check_password(sd->md5key, sd->passwdenc, sd->passwd, login_config.admin_pass) ) ShowNotice("'ladmin'-login: Connection in administration mode REFUSED - invalid password (ip: %s)\n", ip); else { ShowNotice("'ladmin'-login: Connection in administration mode accepted (ip: %s)\n", ip); session[sd->fd]->func_parse = parse_admin; result = true; } return result; }
/** * The /ns release command. * @param u The user who issued the command * @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing. **/ int do_release(User * u) { char *nick = strtok(NULL, " "); char *pass = strtok(NULL, " "); NickAlias *na; if (!nick) { syntax_error(s_NickServ, u, "RELEASE", NICK_RELEASE_SYNTAX); } else if (!(na = findnick(nick))) { notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick); } else if (na->status & NS_VERBOTEN) { notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, na->nick); } else if (na->nc->flags & NI_SUSPENDED) { notice_lang(s_NickServ, u, NICK_X_SUSPENDED, na->nick); } else if (!(na->status & NS_KILL_HELD)) { notice_lang(s_NickServ, u, NICK_RELEASE_NOT_HELD, nick); } else if (pass) { int res = check_password(pass, na->nc->pass); if (res == 1) { release(na, 0); notice_lang(s_NickServ, u, NICK_RELEASED); } else { notice_lang(s_NickServ, u, ACCESS_DENIED); if (res == 0) { alog("%s: RELEASE: invalid password for %s by %s!%s@%s", s_NickServ, nick, u->nick, u->username, u->host); bad_password(u); } } } else { if (group_identified(u, na->nc) || (!(na->nc->flags & NI_SECURE) && is_on_access(u, na->nc))) { release(na, 0); notice_lang(s_NickServ, u, NICK_RELEASED); } else { notice_lang(s_NickServ, u, ACCESS_DENIED); } } return MOD_CONT; }
// Authorize against the opened passwords file. Return 1 if authorized. static int authorize(struct mg_connection *conn, FILE *fp) { struct ah ah; char line[256], f_user[256], ha1[256], f_domain[256], buf[MG_BUF_LEN]; if (!parse_auth_header(conn, buf, sizeof(buf), &ah)) { return 0; } // Loop over passwords file while (fgets(line, sizeof(line), fp) != NULL) { if (sscanf(line, "%[^:]:%[^:]:%s", f_user, f_domain, ha1) != 3) { continue; } if (!strcmp(ah.user, f_user) && !strcmp(conn->ctx->config[AUTHENTICATION_DOMAIN], f_domain)) return check_password(conn->request_info.request_method, ha1, ah.uri, ah.nonce, ah.nc, ah.cnonce, ah.qop, ah.response); } return 0; }
int cgiMain() { int sensor_num; sensor_num = 0; cgiFormInteger("sensor_num", &sensor_num, 0); pdlc_load_light_sensor_from_xml(); if(sensor_num > 50) sensor_num = 50; if(0 == sensor_num) { sensor_num = pwsw_h.sensor_num; } else { pwsw_h.sensor_num = sensor_num; } cgiWriteEnvironment("/CHANGE/THIS/PATH/capcgi.dat"); CookieSet(); cgiHeaderContentType("text/html"); OutHead(); OutBodyStart(); if(0 == check_password()) return 0; //fprintf(cgiOut, "<p> sensor_num=%d -%d</p>\n",pwsw_h.sensor_num,sensor_num); OutBodyConfigForm(sensor_num); OutGroup(sensor_num); OutBodyEnd(); return 0; }
// A handler for the /authorize endpoint. // Login page form sends user name and password to this endpoint. struct session* authorize_ex(struct mg_connection *conn, const struct mg_request_info *request_info) { char user[MAX_USER_LEN], password[MAX_USER_LEN]; struct session *session; if (session = if_authorized(conn, request_info)) return session; // Fetch user name and password. get_qsvar(request_info, "user", user, sizeof(user)); get_qsvar(request_info, "password", password, sizeof(password)); if (check_password(user, password) && (session = new_session()) != NULL) { my_strlcpy(session->user, user, sizeof(session->user)); snprintf(session->random, sizeof(session->random), "%d", rand()); generate_session_id(session->session_id, session->random, session->user); return session; } return 0; }
// A handler for the /authorize endpoint. // Login page form sends user name and password to this endpoint. int authorize(struct mg_connection *conn, const struct mg_request_info *request_info) { char user[MAX_USER_LEN], password[MAX_USER_LEN]; struct session *session; // Fetch user name and password. get_qsvar(request_info, "user", user, sizeof(user)); get_qsvar(request_info, "password", password, sizeof(password)); if (check_password(user, password) && (session = new_session()) != NULL) { // Authentication success: // 1. create new session // 2. set session ID token in the cookie // 3. remove original_url from the cookie - not needed anymore // 4. redirect client back to the original URL // // The most secure way is to stay HTTPS all the time. However, just to // show the technique, we redirect to HTTP after the successful // authentication. The danger of doing this is that session cookie can // be stolen and an attacker may impersonate the user. // Secure application must use HTTPS all the time. my_strlcpy(session->user, user, sizeof(session->user)); snprintf(session->random, sizeof(session->random), "%d", rand()); generate_session_id(session->session_id, session->random, session->user); mg_printf(conn, "HTTP/1.1 302 Found\r\n" "Set-Cookie: session=%s; max-age=3600; http-only\r\n" // Session ID "Set-Cookie: user=%s\r\n"// Set user, needed by Javascript code "Set-Cookie: original_url=/; max-age=0\r\n"// Delete original_url "Location: /\r\n\r\n", session->session_id, session->user); return 1; } else { // Authentication failure, redirect to login. redirect_to_login(conn, request_info); return 0; } }
int cgiMain() { int power_num,group_serial_num[5],group_num,group_idx; int i,j,k; char name[81]; ctrl_group *p_group ; cgiFormInteger("power_num", &power_num, 0); cgiFormInteger("group_num", &group_num, 0); memset(name,0,sizeof(name)); cgiFormStringNoNewlines("serial_num", name, 81); get_serial_num(name,&group_serial_num); if(power_num > 100) power_num = 100; if(group_num > 5) group_num = 5; if(group_serial_num[0] > 100) group_serial_num[0] = 100; if(group_serial_num[1] > 100) group_serial_num[1] = 100; if(group_serial_num[2] > 100) group_serial_num[2] = 100; if(group_serial_num[3] > 100) group_serial_num[3] = 100; if(group_serial_num[4] > 100) group_serial_num[4] = 100; cgiWriteEnvironment("/CHANGE/THIS/PATH/capcgi.dat"); cgiHeaderContentType("text/html"); OutHead(); OutBodyStart(); if(0 == check_password()) return 0; fprintf(cgiOut, "<p>power_num=%d group_num=%d [%d-%d-%d-%d-%d]</p>\n", power_num,group_num,group_serial_num[0],group_serial_num[1], group_serial_num[2],group_serial_num[3],group_serial_num[4]); if(0 == power_num) { fprintf(cgiOut, "<p>数据出错,退出!!</p>\n"); OutBodyEnd(); return 0; } else { pwsw_h.power_num = power_num; pwsw_h.group_num = group_num; pwsw_h.group[0].ctrl_serial_num = group_serial_num[0]; pwsw_h.group[1].ctrl_serial_num = group_serial_num[1]; pwsw_h.group[2].ctrl_serial_num = group_serial_num[2]; pwsw_h.group[3].ctrl_serial_num = group_serial_num[3]; pwsw_h.group[4].ctrl_serial_num = group_serial_num[4]; for(i=0;i<group_num;i++) { p_group = &pwsw_h.group[i]; p_group->projector_on = 0; p_group->ctrl_serial_num = group_serial_num[i]; get_start_time(i,&p_group->start_time); get_end_time(i,&p_group->end_time); for(j=0;j<p_group->ctrl_serial_num;j++) { p_group->serial_info[j].duration_ms = get_duration_ms(i,j); for(k=0;k<power_num;k++) { p_group->serial_info[j].power_status[k]= get_power_status(i,j,k); } } } } //Out_pwsw_xml(); save_to_xml_file(); fprintf(cgiOut, "<p>保存成功,请返回!</p>\n"); fprintf(cgiOut, " <input type=\"button\" name=\"rest\" onclick=\"javascript:history.go(-1)\" value=\"重新载入\" />\n"); OutBodyEnd(); return 0; }