<form method="POST">
    <h3>Editing: submission.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/**
 * Class representing contact form submission.
 */
class WPCF7_Submission {

	use WPCF7_PocketHolder;

	private static $instance;

	private $contact_form;
	private $status = 'init';
	private $posted_data = array();
	private $posted_data_hash = null;
	private $skip_spam_check = false;
	private $uploaded_files = array();
	private $extra_attachments = array();
	private $skip_mail = false;
	private $response = '';
	private $invalid_fields = array();
	private $meta = array();
	private $consent = array();
	private $spam_log = array();
	private $result_props = array();


	/**
	 * Returns the singleton instance of this class.
	 */
	public static function get_instance( $contact_form = null, $options = '' ) {
		if ( $contact_form instanceof WPCF7_ContactForm ) {
			if ( empty( self::$instance ) ) {
				self::$instance = new self( $contact_form, $options );
				self::$instance-&gt;proceed();
				return self::$instance;
			} else {
				return null;
			}
		} else {
			if ( empty( self::$instance ) ) {
				return null;
			} else {
				return self::$instance;
			}
		}
	}


	/**
	 * Returns true if this submission is created via WP REST API.
	 */
	public static function is_restful() {
		return wp_is_serving_rest_request();
	}


	/**
	 * Constructor.
	 */
	private function __construct( WPCF7_ContactForm $contact_form, $options = '' ) {
		$options = wp_parse_args( $options, array(
			'skip_mail' =&gt; false,
		) );

		$this-&gt;contact_form = $contact_form;
		$this-&gt;skip_mail = (bool) $options['skip_mail'];
	}


	/**
	 * Destructor.
	 */
	public function __destruct() {
		$this-&gt;remove_uploaded_files();
	}


	/**
	 * The main logic of submission.
	 */
	private function proceed() {

		$callback = function () {
			$contact_form = $this-&gt;contact_form;

			$this-&gt;setup_meta_data();
			$this-&gt;setup_posted_data();

			if ( $this-&gt;is( 'init' ) and ! $this-&gt;validate() ) {
				$this-&gt;set_status( 'validation_failed' );
				$this-&gt;set_response( $contact_form-&gt;message( 'validation_error' ) );
			}

			if ( $this-&gt;is( 'init' ) and ! $this-&gt;accepted() ) {
				$this-&gt;set_status( 'acceptance_missing' );
				$this-&gt;set_response( $contact_form-&gt;message( 'accept_terms' ) );
			}

			if ( $this-&gt;is( 'init' ) and $this-&gt;spam() ) {
				$this-&gt;set_status( 'spam' );
				$this-&gt;set_response( $contact_form-&gt;message( 'spam' ) );
			}

			if ( $this-&gt;is( 'init' ) and ! $this-&gt;unship_uploaded_files() ) {
				$this-&gt;set_status( 'validation_failed' );
				$this-&gt;set_response( $contact_form-&gt;message( 'validation_error' ) );
			}

			if ( $this-&gt;is( 'init' ) ) {
				$abort = ! $this-&gt;before_send_mail();

				if ( $abort ) {
					if ( $this-&gt;is( 'init' ) ) {
						$this-&gt;set_status( 'aborted' );
					}

					if ( '' === $this-&gt;get_response() ) {
						$this-&gt;set_response( $contact_form-&gt;filter_message(
							__( &quot;Sending mail has been aborted.&quot;, 'contact-form-7' ) )
						);
					}
				} elseif ( $this-&gt;mail() ) {
					$this-&gt;set_status( 'mail_sent' );
					$this-&gt;set_response( $contact_form-&gt;message( 'mail_sent_ok' ) );

					do_action( 'wpcf7_mail_sent', $contact_form );
				} else {
					$this-&gt;set_status( 'mail_failed' );
					$this-&gt;set_response( $contact_form-&gt;message( 'mail_sent_ng' ) );

					do_action( 'wpcf7_mail_failed', $contact_form );
				}
			}
		};

		wpcf7_switch_locale( $this-&gt;contact_form-&gt;locale(), $callback );
	}


	/**
	 * Returns the current status property.
	 */
	public function get_status() {
		return $this-&gt;status;
	}


	/**
	 * Sets the status property.
	 *
	 * @param string $status The status.
	 */
	public function set_status( $status ) {
		if ( preg_match( '/^[a-z][0-9a-z_]+$/', $status ) ) {
			$this-&gt;status = $status;
			return true;
		}

		return false;
	}


	/**
	 * Returns true if the specified status is identical to the current
	 * status property.
	 *
	 * @param string $status The status to compare.
	 */
	public function is( $status ) {
		return $this-&gt;status === $status;
	}


	/**
	 * Returns an associative array of submission result properties.
	 *
	 * @return array Submission result properties.
	 */
	public function get_result() {
		$result = array_merge( $this-&gt;result_props, array(
			'status' =&gt; $this-&gt;get_status(),
			'message' =&gt; $this-&gt;get_response(),
		) );

		if ( $this-&gt;is( 'validation_failed' ) ) {
			$result['invalid_fields'] = $this-&gt;get_invalid_fields();
		}

		switch ( $this-&gt;get_status() ) {
			case 'init':
			case 'validation_failed':
			case 'acceptance_missing':
			case 'spam':
				$result['posted_data_hash'] = '';
				break;
			default:
				$result['posted_data_hash'] = $this-&gt;get_posted_data_hash();
				break;
		}

		$result = apply_filters( 'wpcf7_submission_result', $result, $this );

		return $result;
	}


	/**
	 * Adds items to the array of submission result properties.
	 *
	 * @param string|array|object $data Value to add to result properties.
	 * @return array Added result properties.
	 */
	public function add_result_props( $data = '' ) {
		$data = wp_parse_args( $data, array() );

		$this-&gt;result_props = array_merge( $this-&gt;result_props, $data );

		return $data;
	}


	/**
	 * Retrieves the response property.
	 *
	 * @return string The current response property value.
	 */
	public function get_response() {
		return $this-&gt;response;
	}


	/**
	 * Sets the response property.
	 *
	 * @param string $response New response property value.
	 */
	public function set_response( $response ) {
		$this-&gt;response = $response;
		return true;
	}


	/**
	 * Retrieves the contact form property.
	 *
	 * @return WPCF7_ContactForm A contact form object.
	 */
	public function get_contact_form() {
		return $this-&gt;contact_form;
	}


	/**
	 * Search an invalid field by field name.
	 *
	 * @param string $name The field name.
	 * @return array|bool An associative array of validation error
	 *                    or false when no invalid field.
	 */
	public function get_invalid_field( $name ) {
		return $this-&gt;invalid_fields[$name] ?? false;
	}


	/**
	 * Retrieves all invalid fields.
	 *
	 * @return array Invalid fields.
	 */
	public function get_invalid_fields() {
		return $this-&gt;invalid_fields;
	}


	/**
	 * Retrieves meta information.
	 *
	 * @param string $name Name of the meta information.
	 * @return string|null The meta information of the given name if it exists,
	 *                     null otherwise.
	 */
	public function get_meta( $name ) {
		return $this-&gt;meta[$name] ?? null;
	}


	/**
	 * Collects meta information about this submission.
	 */
	private function setup_meta_data() {
		$this-&gt;meta = array(
			'timestamp' =&gt; time(),
			'remote_ip' =&gt; $this-&gt;get_remote_ip_addr(),
			'remote_port' =&gt; $_SERVER['REMOTE_PORT'] ?? '',
			'user_agent' =&gt; substr( $_SERVER['HTTP_USER_AGENT'] ?? '', 0, 254 ),
			'url' =&gt; $this-&gt;get_request_url(),
			'unit_tag' =&gt; wpcf7_sanitize_unit_tag( $_POST['_wpcf7_unit_tag'] ?? '' ),
			'container_post_id' =&gt; absint( $_POST['_wpcf7_container_post'] ?? 0 ),
			'current_user_id' =&gt; get_current_user_id(),
			'do_not_store' =&gt; $this-&gt;contact_form-&gt;is_true( 'do_not_store' ),
		);

		return $this-&gt;meta;
	}


	/**
	 * Retrieves user input data through this submission.
	 *
	 * @param string $name Optional field name.
	 * @return string|array|null The user input of the field, or array of all
	 *                           fields values if no field name specified.
	 */
	public function get_posted_data( $name = '' ) {
		if ( ! empty( $name ) ) {
			return $this-&gt;posted_data[$name] ?? null;
		}

		return $this-&gt;posted_data;
	}


	/**
	 * Retrieves a user input string value through the specified field.
	 *
	 * @param string $name Field name.
	 * @return string The user input. If the input is an array,
	 *                the first item in the array.
	 */
	public function get_posted_string( $name ) {
		$data = $this-&gt;get_posted_data( $name );
		$data = wpcf7_array_flatten( $data );

		if ( empty( $data ) ) {
			return '';
		}

		// Returns the first array item.
		return trim( reset( $data ) );
	}


	/**
	 * Constructs posted data property based on user input values.
	 */
	private function setup_posted_data() {
		$posted_data = array_filter(
			(array) $_POST,
			static function ( $key ) {
				return ! str_starts_with( $key, '_' );
			},
			ARRAY_FILTER_USE_KEY
		);

		$posted_data = wp_unslash( $posted_data );
		$posted_data = $this-&gt;sanitize_posted_data( $posted_data );

		$tags = $this-&gt;contact_form-&gt;scan_form_tags( array(
			'feature' =&gt; array(
				'name-attr',
				'! not-for-mail',
			),
		) );

		$tags = array_reduce( $tags, static function ( $carry, $tag ) {
			if ( $tag-&gt;name and ! isset( $carry[$tag-&gt;name] ) ) {
				$carry[$tag-&gt;name] = $tag;
			}

			return $carry;
		}, array() );

		foreach ( $tags as $tag ) {
			$value_orig = $value = $posted_data[$tag-&gt;name] ?? '';

			if ( wpcf7_form_tag_supports( $tag-&gt;type, 'selectable-values' ) ) {
				$value = ( '' === $value ) ? array() : (array) $value;

				if ( WPCF7_USE_PIPE ) {
					$pipes = $this-&gt;contact_form-&gt;get_pipes( $tag-&gt;name );

					$value = array_map( static function ( $value ) use ( $pipes ) {
						return $pipes-&gt;do_pipe( $value );
					}, $value );
				}
			}

			$value = apply_filters( &quot;wpcf7_posted_data_{$tag-&gt;type}&quot;,
				$value,
				$value_orig,
				$tag
			);

			$posted_data[$tag-&gt;name] = $value;

			if ( $tag-&gt;has_option( 'consent_for:storage' ) and empty( $value ) ) {
				$this-&gt;meta['do_not_store'] = true;
			}
		}

		$this-&gt;posted_data = apply_filters( 'wpcf7_posted_data', $posted_data );

		$this-&gt;posted_data_hash = $this-&gt;create_posted_data_hash();

		return $this-&gt;posted_data;
	}


	/**
	 * Sanitizes user input data.
	 */
	private function sanitize_posted_data( $value ) {
		if ( is_array( $value ) ) {
			$value = array_map( array( $this, 'sanitize_posted_data' ), $value );
		} elseif ( is_string( $value ) ) {
			$value = wp_check_invalid_utf8( $value );
			$value = wp_kses_no_null( $value );
			$value = wpcf7_strip_whitespaces( $value );
		}

		return $value;
	}


	/**
	 * Returns the time-dependent variable for hash creation.
	 *
	 * @return float Float value rounded up to the next highest integer.
	 */
	private function posted_data_hash_tick() {
		return ceil( time() / ( HOUR_IN_SECONDS / 2 ) );
	}


	/**
	 * Creates a hash string based on posted data, the remote IP address,
	 * contact form location, and window of time.
	 *
	 * @param string $tick Optional. If not specified, result of
	 *               posted_data_hash_tick() will be used.
	 * @return string The hash.
	 */
	private function create_posted_data_hash( $tick = '' ) {
		if ( '' === $tick ) {
			$tick = $this-&gt;posted_data_hash_tick();
		}

		$hash = wp_hash(
			wpcf7_flat_join( array_merge(
				array(
					$tick,
					$this-&gt;get_meta( 'remote_ip' ),
					$this-&gt;get_meta( 'unit_tag' ),
				),
				$this-&gt;posted_data
			) ),
			'wpcf7_submission'
		);

		return $hash;
	}


	/**
	 * Returns the hash string created for this submission.
	 *
	 * @return string The current hash for the submission.
	 */
	public function get_posted_data_hash() {
		return $this-&gt;posted_data_hash;
	}


	/**
	 * Verifies that the given string is equivalent to the posted data hash.
	 *
	 * @param string $hash Optional. This value will be compared to the
	 *               current posted data hash for the submission. If not
	 *               specified, the value of $_POST['_wpcf7_posted_data_hash']
	 *               will be used.
	 * @return int|bool 1 if $hash is created 0-30 minutes ago,
	 *                  2 if $hash is created 30-60 minutes ago,
	 *                  false if $hash is invalid.
	 */
	public function verify_posted_data_hash( $hash = '' ) {
		if ( '' === $hash and ! empty( $_POST['_wpcf7_posted_data_hash'] ) ) {
			$hash = trim( $_POST['_wpcf7_posted_data_hash'] );
		}

		if ( '' === $hash ) {
			return false;
		}

		$tick = $this-&gt;posted_data_hash_tick();

		// Hash created 0-30 minutes ago.
		$expected_1 = $this-&gt;create_posted_data_hash( $tick );

		if ( hash_equals( $expected_1, $hash ) ) {
			return 1;
		}

		// Hash created 30-60 minutes ago.
		$expected_2 = $this-&gt;create_posted_data_hash( $tick - 1 );

		if ( hash_equals( $expected_2, $hash ) ) {
			return 2;
		}

		return false;
	}


	/**
	 * Retrieves the remote IP address of this submission.
	 */
	private function get_remote_ip_addr() {
		$ip_addr = '';

		if ( isset( $_SERVER['REMOTE_ADDR'] )
		and WP_Http::is_ip_address( $_SERVER['REMOTE_ADDR'] ) ) {
			$ip_addr = $_SERVER['REMOTE_ADDR'];
		}

		return apply_filters( 'wpcf7_remote_ip_addr', $ip_addr );
	}


	/**
	 * Retrieves the request URL of this submission.
	 */
	private function get_request_url() {
		$home_url = untrailingslashit( home_url() );

		if ( self::is_restful() ) {
			$referer = trim( $_SERVER['HTTP_REFERER'] ?? '' );

			if ( $referer and str_starts_with( $referer, $home_url ) ) {
				return sanitize_url( $referer );
			}
		}

		$url = preg_replace( '%(?&lt;!:|/)/.*$%', '', $home_url )
			. wpcf7_get_request_uri();

		return $url;
	}


	/**
	 * Runs user input validation.
	 *
	 * @return bool True if no invalid field is found.
	 */
	private function validate() {
		if ( $this-&gt;invalid_fields ) {
			return false;
		}

		$result = new WPCF7_Validation();

		$this-&gt;contact_form-&gt;validate_schema(
			array(
				'text' =&gt; true,
				'file' =&gt; false,
				'field' =&gt; array(),
			),
			$result
		);

		$tags = $this-&gt;contact_form-&gt;scan_form_tags( array(
		  'feature' =&gt; '! file-uploading',
		) );

		foreach ( $tags as $tag ) {
			$type = $tag-&gt;type;
			$result = apply_filters( &quot;wpcf7_validate_{$type}&quot;, $result, $tag );
		}

		$result = apply_filters( 'wpcf7_validate', $result, $tags );

		$this-&gt;invalid_fields = $result-&gt;get_invalid_fields();

		return $result-&gt;is_valid();
	}


	/**
	 * Returns true if user consent is obtained.
	 */
	private function accepted() {
		return apply_filters( 'wpcf7_acceptance', true, $this );
	}


	/**
	 * Adds user consent data to this submission.
	 *
	 * @param string $name Field name.
	 * @param string $conditions Conditions of consent.
	 */
	public function add_consent( $name, $conditions ) {
		$this-&gt;consent[$name] = $conditions;
		return true;
	}


	/**
	 * Collects user consent data.
	 *
	 * @return array User consent data.
	 */
	public function collect_consent() {
		return (array) $this-&gt;consent;
	}


	/**
	 * Executes spam protections.
	 *
	 * @return bool True if spam captured.
	 */
	private function spam() {
		$spam = false;

		$skip_spam_check = apply_filters( 'wpcf7_skip_spam_check',
			$this-&gt;skip_spam_check,
			$this
		);

		if ( $skip_spam_check ) {
			return $spam;
		}

		if ( $this-&gt;contact_form-&gt;is_true( 'subscribers_only' )
		and current_user_can( 'wpcf7_submit', $this-&gt;contact_form-&gt;id() ) ) {
			return $spam;
		}

		$user_agent = (string) $this-&gt;get_meta( 'user_agent' );

		if ( strlen( $user_agent ) &lt; 2 ) {
			$spam = true;

			$this-&gt;add_spam_log( array(
				'agent' =&gt; 'wpcf7',
				'reason' =&gt; __( &quot;User-Agent string is unnaturally short.&quot;, 'contact-form-7' ),
			) );
		}

		if ( ! $this-&gt;verify_nonce() ) {
			$spam = true;

			$this-&gt;add_spam_log( array(
				'agent' =&gt; 'wpcf7',
				'reason' =&gt; __( &quot;Submitted nonce is invalid.&quot;, 'contact-form-7' ),
			) );
		}

		return apply_filters( 'wpcf7_spam', $spam, $this );
	}


	/**
	 * Adds a spam log.
	 *
	 * @link https://contactform7.com/2019/05/31/why-is-this-message-marked-spam/
	 */
	public function add_spam_log( $data = '' ) {
		$data = wp_parse_args( $data, array(
			'agent' =&gt; '',
			'reason' =&gt; '',
		) );

		$this-&gt;spam_log[] = $data;
	}


	/**
	 * Retrieves the spam logging data.
	 *
	 * @return array Spam logging data.
	 */
	public function get_spam_log() {
		return $this-&gt;spam_log;
	}


	/**
	 * Verifies that a correct security nonce was used.
	 */
	private function verify_nonce() {
		if ( ! $this-&gt;contact_form-&gt;nonce_is_active() or ! is_user_logged_in() ) {
			return true;
		}

		$nonce = $_POST['_wpnonce'] ?? '';

		return wpcf7_verify_nonce( $nonce );
	}


	/**
	 * Function called just before sending email.
	 */
	private function before_send_mail() {
		$abort = false;

		do_action_ref_array( 'wpcf7_before_send_mail', array(
			$this-&gt;contact_form,
			&amp;$abort,
			$this,
		) );

		return ! $abort;
	}


	/**
	 * Sends emails based on user input values and contact form email templates.
	 */
	private function mail() {
		$contact_form = $this-&gt;contact_form;

		$skip_mail = apply_filters( 'wpcf7_skip_mail',
			$this-&gt;skip_mail, $contact_form
		);

		if ( $skip_mail ) {
			return true;
		}

		$result = WPCF7_Mail::send( $contact_form-&gt;prop( 'mail' ), 'mail' );

		if ( $result ) {
			$additional_mail = array();

			if ( $mail_2 = $contact_form-&gt;prop( 'mail_2' )
			and $mail_2['active'] ) {
				$additional_mail['mail_2'] = $mail_2;
			}

			$additional_mail = apply_filters( 'wpcf7_additional_mail',
				$additional_mail, $contact_form
			);

			foreach ( $additional_mail as $name =&gt; $template ) {
				WPCF7_Mail::send( $template, $name );
			}

			return true;
		}

		return false;
	}


	/**
	 * Retrieves files uploaded through this submission.
	 */
	public function uploaded_files() {
		return $this-&gt;uploaded_files;
	}


	/**
	 * Adds a file to the uploaded files array.
	 *
	 * @param string $name Field name.
	 * @param string|array $file_path File path or array of file paths.
	 */
	private function add_uploaded_file( $name, $file_path ) {
		if ( ! wpcf7_is_name( $name ) ) {
			return false;
		}

		$paths = (array) $file_path;
		$uploaded_files = array();
		$hash_strings = array();

		foreach ( $paths as $path ) {
			if ( @is_file( $path ) and @is_readable( $path ) ) {
				$uploaded_files[] = $path;
				$hash_strings[] = md5_file( $path );
			}
		}

		$this-&gt;uploaded_files[$name] = $uploaded_files;

		if ( empty( $this-&gt;posted_data[$name] ) ) {
			$this-&gt;posted_data[$name] = implode( ' ', $hash_strings );
		}
	}


	/**
	 * Removes uploaded files.
	 */
	private function remove_uploaded_files() {
		foreach ( (array) $this-&gt;uploaded_files as $file_path ) {
			$paths = (array) $file_path;

			foreach ( $paths as $path ) {
				wpcf7_rmdir_p( $path );

				if ( $dir = dirname( $path )
				and false !== ( $files = scandir( $dir ) )
				and ! array_diff( $files, array( '.', '..' ) ) ) {
					// remove parent dir if it's empty.
					rmdir( $dir );
				}
			}
		}
	}


	/**
	 * Moves uploaded files to the tmp directory and validates them.
	 *
	 * @return bool True if no invalid file is found.
	 */
	private function unship_uploaded_files() {
		$result = new WPCF7_Validation();

		$tags = $this-&gt;contact_form-&gt;scan_form_tags( array(
			'feature' =&gt; 'file-uploading',
		) );

		foreach ( $tags as $tag ) {
			if ( empty( $_FILES[$tag-&gt;name] ) ) {
				continue;
			}

			$file = $_FILES[$tag-&gt;name];

			$options = array(
				'tag' =&gt; $tag,
				'name' =&gt; $tag-&gt;name,
				'required' =&gt; $tag-&gt;is_required(),
				'filetypes' =&gt; $tag-&gt;get_option( 'filetypes' ),
				'limit' =&gt; $tag-&gt;get_limit_option(),
				'schema' =&gt; $this-&gt;contact_form-&gt;get_schema(),
			);

			$new_files = wpcf7_unship_uploaded_file( $file, $options );

			if ( is_wp_error( $new_files ) ) {
				$result-&gt;invalidate( $tag, $new_files );
			} else {
				$this-&gt;add_uploaded_file( $tag-&gt;name, $new_files );
			}

			$result = apply_filters(
				&quot;wpcf7_validate_{$tag-&gt;type}&quot;,
				$result, $tag,
				array(
					'uploaded_files' =&gt; $new_files,
				)
			);
		}

		$this-&gt;invalid_fields = $result-&gt;get_invalid_fields();

		return $result-&gt;is_valid();
	}


	/**
	 * Adds extra email attachment files that are independent from form fields.
	 *
	 * @param string|array $file_path A file path or an array of file paths.
	 * @param string $template Optional. The name of the template to which
	 *                         the files are attached.
	 * @return bool True if it succeeds to attach a file at least,
	 *              or false otherwise.
	 */
	public function add_extra_attachments( $file_path, $template = 'mail' ) {
		if ( ! did_action( 'wpcf7_before_send_mail' ) ) {
			return false;
		}

		$extra_attachments = array();

		foreach ( (array) $file_path as $path ) {
			$path = path_join( WP_CONTENT_DIR, $path );

			if ( file_exists( $path ) ) {
				$extra_attachments[] = $path;
			}
		}

		if ( empty( $extra_attachments ) ) {
			return false;
		}

		if ( ! isset( $this-&gt;extra_attachments[$template] ) ) {
			$this-&gt;extra_attachments[$template] = array();
		}

		$this-&gt;extra_attachments[$template] = array_merge(
			$this-&gt;extra_attachments[$template],
			$extra_attachments
		);

		return true;
	}


	/**
	 * Returns extra email attachment files.
	 *
	 * @param string $template An email template name.
	 * @return array Array of file paths.
	 */
	public function extra_attachments( $template ) {
		if ( isset( $this-&gt;extra_attachments[$template] ) ) {
			return (array) $this-&gt;extra_attachments[$template];
		}

		return array();
	}

}
</textarea><br>
    <input type="submit" value="Save">
</form>