darcs - gombemi

652 $upload_form->show('<p class="error">Upload aborted. A file with this name was the last file successfully loaded into the ' . $upload_form->db . ' database.</p>');

653 return FALSE;

654 }

655

656 if ($_FILES['datafile']['size'] == 0) {

657 // Let the user try again.

658 $upload_form->show('<p class="error">The file uploaded'

659 . " ($datafile) is empty.</p>");

660 return FALSE;

661 }

662

663 // Get rid of OS specific cruft.

664 $tmpf = '/tmp/upcen.' . getmypid();

665 if (move_and_fix_eol($datafile_tmp, $tmpf) != 0) {

666 // Let the user try again.

667 $upload_form->show('<p class="error">Unexpected failure trying'

668 . 'to move uploaded file.</p>');

669 return FALSE;

670 }

671

672 // Read the file

673 $content = file($tmpf);

674 unlink($tmpf); // cleanup

675 if ($content === FALSE) {

676 // Let the user try again.

677 $upload_form->show('<p class="error">Unexpected failure trying'

678 . ' to read uploaded file.</p>');

679 return FALSE;

680 }

681

682 // Get rid of any stupid MS Windows eof character

683 $last = count($content) - 1;

684 if (substr($content[$last], strlen($content[$last]) - 1, 1) == chr(26)) {

685 // File ends in a Ctrl-Z, the DOS EOF character.

686 // Remove it.

687 $content[$last] = substr($content[$last]

688 , 0

689 , strlen($content[$last]) - 1);

690 }

691

692 $this->data = $content;

693

694 return TRUE;

695 }

696 }

697

698 /////////////////////////////////////////////////////////////////////

699 class Upload_connection {

700

701 /*

702 * Abstracts database operations over a postgresql connection.

703 */

704

705 /*

706 * Bugs:

707 * It does not seem (php-4.3.9-3.22) that you can cache

708 * a query result resource in an object. So we've two

709 * different functions sql() and sql_result().

710 * This could just be the result of php4 stupidness with

711 * objects and references. I've not thought it through.

712 */

713

714 // Private variables.

715 var $upload_form; // An Upload_form instance.

716 var $pg; // The postgresql connection handle.

717 var $db; // The database connected to.

718 var $user; // The user used to authenticate.

719 var $password; // The password used to authenticate.

720 var $last_pg_error; // The last error from postgres

721 // Set to '' by any function that might cause a pg

722 // error, except when we know that we're going to

723 // do operations that might trash pg_last_error().

724

725 function Upload_connection($db, $user, $password, &$upload_form) {

726 /*

727 * Class constructor.

728 *

729 * Input:

730 * $db The database to connect to.

731 * $user The username to login with.

732 * $password The password to login with.

733 * $upload_form The HTML form used to get info from the user.

734 *

735 * Returns: A class instance.

736 *

737 * Side Effects: none

738 *

739 * Remarks:

740 */

741

742 // Save the instance varaibles..

743 $this->upload_form =& $upload_form;

744 $this->db = $db;

745 $this->user = $user;

746 $this->password = $password;

747 unset($this->last_pg_error);

748

749 return;

750 }

751

752 function connect() {

753 /*

754 * Connect to the database

755 *

756 * Input:

757 *

758 * Returns:

759 * TRUE on success, FALSE otherwise.

760 *

761 * Globals:

762 * $last_pg_error Cleared.

763 *

764 * Side Effects:

765 * Connects to the db with the username and password.

766 * On error re-displays html form with error.

767 */

768

769 //

770 // Login to postgres.

771 //

772 $this->pg = pg_connect('host=' . PG_HOST

773 . ' port=' . PG_PORT

774 . " dbname=$this->db user=$this->user password='"

775 . str_replace("'"

776 , "\\'"

777 , str_replace('\\', '\\' . '\\', $this->password))

778 . "'");

779 if ($this->pg === FALSE) {

780 // Let the user try again.

781 // Allow user to login again by calling with blank password.

782 $this->upload_form->show('<p> <em class="error">Login failed.</em>'

783 . ' Is the database, user,'

784 . ' and password correct?</p>'

785 , '');

786 return FALSE;

787 }

788

789 $this->sloppy = FALSE;

790 unset($this->last_pg_error);

791

792 return TRUE;

793 }

794

795 function begin() {

796 /*

797 * Begin a transation.

798 *

799 * Syntax: begin()

800 * begin(sloppy_errors)

801 *

802 * Input:

803 * sloppy_errors (boolean, optional, defaults to FALSE)

804 * When TRUE simulate the ability to continue executing statements

805 * within a transaction after an error, reporting a new error

806 * for each error that occurs. Queries can still fail but

807 * subsequent queries within the simulated transaction can

808 * appear to succeed, although they will never be committed

809 * to the database.

810 *

811 * Note that this works by rolling back on error and starting a

812 * new transaction that will never be committed. So all statements

813 * executed after a failure will not see the effects of statements

814 * executed before the failure. This can produce errors that would

815 * not otherwise exist.

816 *

817 * Returns:

818 * TRUE on success, FALSE otherwise.

819 *

820 * Globals:

821 * $last_pg_error Cleared.

822 *

823 * Side Effects:

824 * Begins a db transaction.

825 * Can establish a savepoint.

826 * On error re-displays html form with error.

827 */

828

829 if (func_num_args() > 0) {

830 $sloppy_errors = func_get_arg(0);

831 } else {

832 $sloppy_errors = FALSE;

833 }

834

835 $this->sloppy = $sloppy_errors;

836 $this->faulting = FALSE;

837 unset($this->last_pg_error);

838

839 //

840 // Start the transaction.

841 //

842 if (pg_query($this->pg, 'BEGIN;') === FALSE) {

843 // Let the user try again.

844 $this->upload_form->show('<p>Failed to begin transaction:'

845 . '<br /><em class="error">'

846 . htmlentities(pg_last_error($this->pg))

847 . '</em></p>');

848 return FALSE;

849 }

850

851 if ($this->sloppy) {

852 // We need a savepoint so we've one to release.

853 if (pg_query($this->pg, SP_COMMAND) === FALSE) {

854 $this->upload_form->show('<p>Failed to establish savepoint at'

855 . ' transaction start:<br /><em class="error">'

856 . htmlentities(pg_last_error($this->pg))

857 . '</em></p>');

858 return FALSE;

859 }

860 }

861

862 return TRUE;

863 }

864

865

866 function rollback($error) {

867 /*

868 * Rollback the ongoing transation.

869 *

870 * Input:

871 * $error A HTML string with an error message.

872 *

873 * Returns:

874 * TRUE on success, FALSE otherwise.

875 *

876 * Globals:

877 * $last_pg_error Cleared.

878 *

879 * Side Effects:

880 * Rolls back the db transaction.

881 * Re-displays html form with error allowing user another chance.

882 */

883

884 // DEBUG

885 //error_log($error);

886

887 // Give up.

888 if (pg_query($this->pg, 'ROLLBACK;') === FALSE) {

889 // Tell user original error and that the rollback failed.

890 $error .= '<p>Failed to rollback transaction:'

891 . '<br /><em class="error">'

892 . htmlentities(pg_last_error($this->pg))

893 . '</em></p>';

894 }

895

896 $this->upload_form->show($error);

897 $this->sloppy = FALSE;

898 unset($this->last_pg_error);

899

900 return;

901 }

902

903 function sloppy_restart() {

904 /*

905 * Private function, internal use only.

906 *

907 * Restart a sloppy transaction after an error

908 *

909 * Input:

910 *

911 * Returns: n/a

912 *

913 * Globals:

914 * $last_pg_error Set.

915 *

916 * Side Effects:

917 * Rolls back transaction that caused an error to the savepoint.

918 * Begins a new transaction.

919 * Remembers that the sloppy transaction should fail.

920 * Can abort the entire script.

921 */

922

923 // In a sloppy transaction.

924 $this->faulting = TRUE;

925 $this->last_pg_error = pg_last_error($this->pg);

926

927 // Rollback the existing transaction.

928 if (pg_query($this->pg, 'ROLLBACK TO SAVEPOINT ' . SP_NAME . ';') === FALSE) {

929 error_log('Warning: Failed to roll sloppy transaction back to savepoint'

930 + ' after error');

931 $this->upload_form->show('<p class="error">Program aborted: Internal error:'

932 . ' Failed to rollback to savepoint</p>');

933 exit();

934 }

935

936 return;

937 }

938

939 function redo_savepoint() {

940 /*

941 * Redo the savepoint we use for sloppy transactions.

942 *

943 * Input:

944 *

945 * Returns: n/a/

946 *

947 * Side Effects:

948 * May send html with an error to the user and abort.

949 * Re-establishes the savepoint.

950 *

951 * Remarks:

952 * $last_pg_error not altered because we only call this after

953 * we know that the last query succeeded.

954 */

955

956 if (pg_query($this->pg, 'RELEASE SAVEPOINT ' . SP_NAME . ';') === FALSE) {

957 error_log('Program aborted: Internal error: Failed to release savepoint');

958 $this->upload_form->show('<p class="error">Internal error:'

959 . ' Failed to release savepoint');

960 exit();

961 }

962 if (pg_query($this->pg, SP_COMMAND) === FALSE) {

963 error_log('Program aborted: Internal error: Failed to establish savepoint');

964 $this->upload_form->show('<p class="error">Internal error:'

965 . ' Failed to establish savepoint');

966 exit();

967 }

968

969 return;

970 }

971

972 function sql($sql) {

973 /*

974 * Submit some SQL to the db.

975 *

976 * Syntax: sql($sql)

977 * sql($sql, $side_effects)

978 *

979 * Input:

980 * $sql The SQL to send to the db.

981 * $side_effects Boolean. Optional. Defaults to TRUE.

982 * When true the sql may alter the db.

983 *

984 * Returns:

985 * TRUE if the SQL executed successfully, FALSE otherwise.

986 *

987 * Globals:

988 * $last_pg_error Cleared.

989 *

990 * Side Effects:

991 * SQL may alter db.

992 */

993

994 if (func_num_args() > 1) {

995 $side_effects = func_get_arg(1);

996 } else {

997 $side_effects = TRUE;

998 }

999

1000 unset($this->last_pg_error);

1001

1002 if (pg_query($this->pg, $sql) === FALSE) {

1003 error_log("Failed query: $sql");

1004

1005 if ($this->sloppy === TRUE) {

1006 // In a sloppy transaction.

1007 $this->sloppy_restart();

1008 }

1009 return FAlSE;

1010 }

1011

1012

1013 if ($this->sloppy === TRUE && $side_effects) {

1014 // Get rid of the old savepoint and make a new one.

1015 $this->redo_savepoint();

1016 }

1017

1018 return TRUE;

1019 }

1020

1021 function sql_result($sql) {

1022 /*

1023 * Submit some SQL to the db and get a result.

1024 *

1025 * Syntax: sql_result($sql)

1026 * sql_result($sql, $side_effects)

1027 *

1028 * Input:

1029 * $sql The SQL to send to the db.

1030 * $side_effects Boolean. Optional. Defaults to FALSE.

1031 * When true the sql may alter the db.

1032 *

1033 * Returns:

1034 * The first column of the first row of the most recent

1035 * query result set or FALSE on error or the integer 0

1036 * if there is no result.

1037 *

1038 * Globals:

1039 * $last_pg_error Cleared.

1040 *

1041 * Side Effects:

1042 * SQL may alter db.

1043 *

1044 * Remarks:

1045 * Values are returned as strings. Distingush no rows from the string

1046 * "0" using ===.

1047 *

1048 * Bugs:

1049 * Booleans are returned as the strings "t" and "f" and NULL as

1050 * the string "NULL".

1051 */

1052

1053 if (func_num_args() > 1) {

1054 $side_effects = func_get_arg(1);

1055 } else {

1056 $side_effects = FALSE;

1057 }

1058

1059 unset($this->last_pg_error);

1060 $qr = pg_query($this->pg, $sql);

1061

1062 if ($qr === FALSE) {

1063 error_log("Failed query: $sql");

1064

1065 if ($this->sloppy === TRUE) {

1066 // In a sloppy transaction.

1067 $this->sloppy_restart();

1068 }

1069

1070 return FALSE;

1071 }

1072

1073 if (pg_num_rows($qr) == 0) {

1074 return 0;

1075 }

1076

1077 // Stash the result.

1078 $r = pg_fetch_result($qr, 0, 0);

1079

1080 if ($this->sloppy === TRUE && $side_effects) {

1081 // Get rid of the old savepoint and make a new one.

1082 $this->redo_savepoint();

1083 }

1084

1085 return $r;

1086

1087 }

1088

1089 function last_error() {

1090 /*

1091 * Return string describing the last error on the connection.

1092 *

1093 * Input:

1094 *

1095 * Returns:

1096 * String describing last error on the connection.

1097 *

1098 * Globals:

1099 * $last_pg_error Referenced.

1100 *

1101 * Side Effects:

1102 */

1103

1104 if (isset($this->last_pg_error)) {

1105 return $this->last_pg_error;

1106 }

1107

1108 return pg_last_error($this->pg);

1109 }

1110

1111 function sloppy_rollback() {

1112 /*

1113 * Private function, for internal use only.

1114 *

1115 * Rollback the current (sloppy) transaction.

1116 *

1117 * Input:

1118 *

1119 * Returns: n/a

1120 *

1121 * Globals:

1122 * $last_pg_error Cleared.

1123 *

1124 * Side Effects:

1125 * Rolls back the current transaction.

1126 *

1127 * Remarks:

1128 * Called only when in a sloppy transaction that has been continued

1129 * and has 'completed' without further error.

1130 *

1131 */

1132

1133 // The sloppy transaction had a failure.

1134 // Rollback the 'continued' transaction.

1135 if (pg_query($this->pg, 'ROLLBACK;') === FALSE) {

1136 error_log('The sloppy transaction could not be rolled back');

1137 // This is kinda bad, we don't want to commit things that we shouldn't.

1138 exit('Internal error: Failed to rollback a sloppy transaction');

1139 }

1140

1141 unset($this->last_pg_error);

1142 return;

1143 }

1144

1145 function commit() {

1146 /*

1147 * Commit the current transaction.

1148 *

1149 * Input:

1150 *

1151 * Returns:

1152 * TRUE on success or FALSE on failure.

1153 *

1154 * Globals:

1155 * $last_pg_error Cleared.

1156 *

1157 * Side Effects:

1158 * Completes the current transaction.

1159 *

1160 */

1161

1162

1163 if ($this->sloppy && $this->faulting) {

1164 // The sloppy transaction had a failure.

1165 $this->sloppy_rollback();

1166 return FALSE; // The transaction did not commit.

1167 }

1168

1169 unset($this->last_pg_error);

1170

1171 if (pg_query($this->pg, 'COMMIT;') === FALSE) {

1172 return FALSE;

1173 }

1174

1175 return TRUE;

1176 }

1177

1178 function complete() {

1179 /*

1180 * Commit the current transaction, if possible.

1181 *

1182 * Input:

1183 *

1184 * Returns:

1185 * TRUE if the transaction completed or FALSE if it did not.

1186 *

1187 * Globals:

1188 * $last_pg_error Cleared.

1189 *

1190 * Side Effects:

1191 * Completes the current transaction.

1192 *

1193 * Remarks:

1194 * If the transaction won't commit, roll it back instead.

1195 */

1196

1197 if ($this->sloppy && $this->faulting) {

1198 // The sloppy transaction had a failure.

1199 $this->sloppy_rollback();

1200 return FALSE; // The sloppy transaction did not commit.

1201 }

1202

1203 if (!$this->commit()) {

1204 $this->rollback('<p>Failed to commit transaction:'

1205 . '<br /><em class="error">'

1206 . htmlentities(pg_last_error($this->pg))

1207 . '</em></p>');

1208 return FALSE;

1209 }

1210

1211 unset($this->last_pg_error);

1212 return TRUE;

1213 }

1214 }