自学教程：C++ FreeFile函数代码示例

bool TSFrameReader::SetFile(string filePath) {	FreeFile();	_freeFile = true;	_pFile = GetFile(filePath, 4 * 1024 * 1024);	if (_pFile == NULL) {		FATAL("Unable to open file %s", STR(filePath));		return false;	}	if (!DetermineChunkSize()) {		FATAL("Unable to determine chunk size");		FreeFile();		return false;	}	SetChunkSize(_chunkSize);	if (!_pFile->SeekTo(_chunkSizeDetectionCount)) {		FATAL("Unable to seek to the beginning of file");		FreeFile();		return false;	}	_eof = _pFile->IsEOF();	_defaultBlockSize = ((1024 * 1024 * 2) / _chunkSize) * _chunkSize;	return true;}

/* Dumps the histogram data into a file (with a md5 hash of the contents at the beginning). */staticvoid pg_record_shmem_shutdown(int code, Datum arg) {        FILE * file;        /* do we need to write the queries? */    if (query_buffer->next == 0) {        return;    }        prepare_file(log_file, query_buffer, query_buffer->next);        file = AllocateFile(log_file->curr_filename, PG_BINARY_A);    if (file == NULL)        goto error;        /* now write the actual shared segment */    if (fwrite(query_buffer->buffer, query_buffer->next, 1, file) != 1)       goto error;        FreeFile(file);        return;error:    ereport(LOG,            (errcode_for_file_access(),             errmsg("could not write query buffer to the file /"%s/": %m",                    log_file->curr_filename)));    if (file)        FreeFile(file);    }

/* Dumps the histogram data into a file (with a md5 hash of the contents at the beginning). */staticvoid buffer_write() {        FILE * file;        prepare_file(log_file, query_buffer, query_buffer->next);        file = AllocateFile(log_file->curr_filename, PG_BINARY_A);    if (file == NULL)        goto error;        /* now write the actual shared segment */    if (fwrite(query_buffer->buffer, query_buffer->next, 1, file) != 1)        goto error;        FreeFile(file);        return;error:    ereport(LOG,            (errcode_for_file_access(),             errmsg("could not write query histogram file /"%s/": %m",                    log_file->curr_filename)));    if (file)        FreeFile(file);    }

/* * shmem_shutdown hook: Dump statistics into file. * * Note: we don't bother with acquiring lock, because there should be no * other processes running when this is called. */static voidpgss_shmem_shutdown(int code, Datum arg){	FILE	   *file;	HASH_SEQ_STATUS hash_seq;	int32		num_entries;	pgssEntry  *entry;	/* Don't try to dump during a crash. */	if (code)		return;	/* Safety check ... shouldn't get here unless shmem is set up. */	if (!pgss || !pgss_hash)		return;	/* Don't dump if told not to. */	if (!pgss_save)		return;	file = AllocateFile(PGSS_DUMP_FILE, PG_BINARY_W);	if (file == NULL)		goto error;	if (fwrite(&PGSS_FILE_HEADER, sizeof(uint32), 1, file) != 1)		goto error;	num_entries = hash_get_num_entries(pgss_hash);	if (fwrite(&num_entries, sizeof(int32), 1, file) != 1)		goto error;	hash_seq_init(&hash_seq, pgss_hash);	while ((entry = hash_seq_search(&hash_seq)) != NULL)	{		int			len = entry->key.query_len;		if (fwrite(entry, offsetof(pgssEntry, mutex), 1, file) != 1 ||			fwrite(entry->query, 1, len, file) != len)			goto error;	}	if (FreeFile(file))	{		file = NULL;		goto error;	}	return;error:	ereport(LOG,			(errcode_for_file_access(),			 errmsg("could not write pg_stat_statement file /"%s/": %m",					PGSS_DUMP_FILE)));	if (file)		FreeFile(file);	unlink(PGSS_DUMP_FILE);}

/* * CREATE FUNCTION utl_file.fcopy( *     src_location		text, *     src_filename		text, *     dest_location	text, *     dest_filename	text, *     start_line		integer DEFAULT NULL *     end_line			integer DEFAULT NULL) */Datumutl_file_fcopy(PG_FUNCTION_ARGS){	char	   *srcpath;	char	   *dstpath;	int			start_line;	int			end_line;	FILE	   *srcfile;	FILE	   *dstfile;	NOT_NULL_ARG(0);	NOT_NULL_ARG(1);	NOT_NULL_ARG(2);	NOT_NULL_ARG(3);	srcpath = get_safe_path(PG_GETARG_TEXT_P(0), PG_GETARG_TEXT_P(1));	dstpath = get_safe_path(PG_GETARG_TEXT_P(2), PG_GETARG_TEXT_P(3));	start_line = PG_GETARG_IF_EXISTS(4, INT32, 1);	if (start_line <= 0)		ereport(ERROR,				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),				errmsg("start_line must be positive (%d passed)", start_line)));	end_line = PG_GETARG_IF_EXISTS(5, INT32, INT_MAX);	if (end_line <= 0)		ereport(ERROR,				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),				errmsg("end_line must be positive (%d passed)", end_line)));	srcfile = AllocateFile(srcpath, "rt");	if (srcfile == NULL)	{		/* failed to open src file. */		IO_EXCEPTION();	}	dstfile = AllocateFile(dstpath, "wt");	if (dstfile == NULL)	{		/* failed to open dst file. */		fclose(srcfile);		IO_EXCEPTION();	}	if (copy_text_file(srcfile, dstfile, start_line, end_line))		IO_EXCEPTION();	FreeFile(srcfile);	FreeFile(dstfile);	PG_RETURN_VOID();}

/** * @brief clean up Reader structure. */int64ReaderClose(Reader *rd, bool onError){	int64	skip = 0;	if (rd == NULL)		return 0;	/* Close and release members. */	if (rd->parser)		skip = ParserTerm(rd->parser);	CheckerTerm(&rd->checker);	if (!onError)	{		if (rd->parse_fp != NULL && FreeFile(rd->parse_fp) < 0)			ereport(WARNING,					(errcode_for_file_access(),					 errmsg("could not close parse bad file /"%s/": %m",							rd->parse_badfile)));		if (rd->infile != NULL)			pfree(rd->infile);		if (rd->logfile != NULL)			pfree(rd->logfile);		if (rd->parse_badfile != NULL)			pfree(rd->parse_badfile);		pfree(rd);	}	return skip;}

/* * Close down after reading a file with tsearch_readline() */voidtsearch_readline_end(tsearch_readline_state *stp){	FreeFile(stp->fp);	/* Pop the error context stack */	error_context_stack = stp->cb.previous;}

//------------------------------------------------------int FrameSeq::Load(AnsiString filename){   FreeFile();   try {File=new TFileStream(filename,fmOpenRead|fmShareExclusive);}   catch(...) {return 1;}   File->Seek(0,soFromBeginning);   Header=new __int8[4100];   File->Read(Header,4100);   File->Seek(108,soFromBeginning);   short int datatype;   File->Read(&datatype,2);   if(datatype == 0) return 2; //FLOATING POINT intensity format is not supported   DatLength=datatype>1?2:4;   File->Seek(1446,soFromBeginning);   int NFramestemp=0,XDimtemp=0,YDimtemp=0;   File->Read(&NFramestemp,4);   File->Seek(42,soFromBeginning);   File->Read(&XDimtemp,2);   File->Seek(656,soFromBeginning);   File->Read(&YDimtemp,2);   if( (NFramestemp<1)||(NFramestemp>MaxFrames)||(!datatype)||(XDimtemp<1)     ||(XDimtemp>MaxDim)||(YDimtemp<1)||(YDimtemp>MaxDim) )   {      delete File; File=NULL;      return 1;   }   NFrames=NFramestemp;   XDim=XDimtemp; YDim=YDimtemp;   CurFrame=new Frame(XDim,YDim);//   LoadFrame(1);   return 0;};

/* * XLogArchiveNotify * * Create an archive notification file * * The name of the notification file is the message that will be picked up * by the archiver, e.g. we write 0000000100000001000000C6.ready * and the archiver then knows to archive XLOGDIR/0000000100000001000000C6, * then when complete, rename it to 0000000100000001000000C6.done */voidXLogArchiveNotify(const char *xlog){	char		archiveStatusPath[MAXPGPATH];	FILE	   *fd;	/* insert an otherwise empty file called <XLOG>.ready */	StatusFilePath(archiveStatusPath, xlog, ".ready");	fd = AllocateFile(archiveStatusPath, "w");	if (fd == NULL)	{		ereport(LOG,				(errcode_for_file_access(),				 errmsg("could not create archive status file /"%s/": %m",						archiveStatusPath)));		return;	}	if (FreeFile(fd))	{		ereport(LOG,				(errcode_for_file_access(),				 errmsg("could not write archive status file /"%s/": %m",						archiveStatusPath)));		return;	}	/* Notify archiver that it's got something to do */	if (IsUnderPostmaster)		SendPostmasterSignal(PMSIGNAL_WAKEN_ARCHIVER);}

/* * FindMyDatabase -- get the critical info needed to locate my database * * Find the named database in pg_database, return its database OID and the * OID of its default tablespace.  Return TRUE if found, FALSE if not. * * Since we are not yet up and running as a backend, we cannot look directly * at pg_database (we can't obtain locks nor participate in transactions). * So to get the info we need before starting up, we must look at the "flat * file" copy of pg_database that is helpfully maintained by flatfiles.c. * This is subject to various race conditions, so after we have the * transaction infrastructure started, we have to recheck the information; * see InitPostgres. */static boolFindMyDatabase(const char *name, Oid *db_id, Oid *db_tablespace){    bool		result = false;    char	   *filename;    FILE	   *db_file;    char		thisname[NAMEDATALEN];    TransactionId db_frozenxid;    filename = database_getflatfilename();    db_file = AllocateFile(filename, "r");    if (db_file == NULL)        ereport(FATAL,                (errcode_for_file_access(),                 errmsg("could not open file /"%s/": %m", filename)));    while (read_pg_database_line(db_file, thisname, db_id,                                 db_tablespace, &db_frozenxid))    {        if (strcmp(thisname, name) == 0)        {            result = true;            break;        }    }    FreeFile(db_file);    pfree(filename);    return result;}

/* * Returns start time of an online exclusive backup. * * When there's no exclusive backup in progress, the function * returns NULL. */Datumpg_backup_start_time(PG_FUNCTION_ARGS){	Datum		xtime;	FILE	   *lfp;	char		fline[MAXPGPATH];	char		backup_start_time[30];	/*	 * See if label file is present	 */	lfp = AllocateFile(BACKUP_LABEL_FILE, "r");	if (lfp == NULL)	{		if (errno != ENOENT)			ereport(ERROR,					(errcode_for_file_access(),					 errmsg("could not read file /"%s/": %m",							BACKUP_LABEL_FILE)));		PG_RETURN_NULL();	}	/*	 * Parse the file to find the START TIME line.	 */	backup_start_time[0] = '/0';	while (fgets(fline, sizeof(fline), lfp) != NULL)	{		if (sscanf(fline, "START TIME: %25[^/n]/n", backup_start_time) == 1)			break;	}	/* Check for a read error. */	if (ferror(lfp))		ereport(ERROR,				(errcode_for_file_access(),			   errmsg("could not read file /"%s/": %m", BACKUP_LABEL_FILE)));	/* Close the backup label file. */	if (FreeFile(lfp))		ereport(ERROR,				(errcode_for_file_access(),			  errmsg("could not close file /"%s/": %m", BACKUP_LABEL_FILE)));	if (strlen(backup_start_time) == 0)		ereport(ERROR,				(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),				 errmsg("invalid data in file /"%s/"", BACKUP_LABEL_FILE)));	/*	 * Convert the time string read from file to TimestampTz form.	 */	xtime = DirectFunctionCall3(timestamptz_in,								CStringGetDatum(backup_start_time),								ObjectIdGetDatum(InvalidOid),								Int32GetDatum(-1));	PG_RETURN_DATUM(xtime);}

/* * Read a section of a file, returning it as text */Datumpg_read_file(PG_FUNCTION_ARGS){	text	   *filename_t = PG_GETARG_TEXT_P(0);	int64		seek_offset = PG_GETARG_INT64(1);	int64		bytes_to_read = PG_GETARG_INT64(2);	char	   *buf;	size_t		nbytes;	FILE	   *file;	char	   *filename;	if (!superuser())		ereport(ERROR,				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),				 (errmsg("must be superuser to read files"))));	filename = convert_and_check_filename(filename_t);	if ((file = AllocateFile(filename, PG_BINARY_R)) == NULL)		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not open file /"%s/" for reading: %m",						filename)));	if (fseeko(file, (off_t) seek_offset,			   (seek_offset >= 0) ? SEEK_SET : SEEK_END) != 0)		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not seek in file /"%s/": %m", filename)));	if (bytes_to_read < 0)		ereport(ERROR,				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),				 errmsg("requested length cannot be negative")));	/* not sure why anyone thought that int64 length was a good idea */	if (bytes_to_read > (MaxAllocSize - VARHDRSZ))		ereport(ERROR,				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),				 errmsg("requested length too large")));	buf = palloc((Size) bytes_to_read + VARHDRSZ);	nbytes = fread(VARDATA(buf), 1, (size_t) bytes_to_read, file);	if (ferror(file))		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not read file /"%s/": %m", filename)));	SET_VARSIZE(buf, nbytes + VARHDRSZ);	FreeFile(file);	pfree(filename);	PG_RETURN_TEXT_P(buf);}

/* * Read a section of a file, returning it as bytea * * Caller is responsible for all permissions checking. * * We read the whole of the file when bytes_to_read is negative. */bytea *read_binary_file(const char *filename, int64 seek_offset, int64 bytes_to_read){	bytea	   *buf;	size_t		nbytes;	FILE	   *file;	if (bytes_to_read < 0)	{		if (seek_offset < 0)			bytes_to_read = -seek_offset;		else		{			struct stat fst;			if (stat(filename, &fst) < 0)				ereport(ERROR,						(errcode_for_file_access(),						 errmsg("could not stat file /"%s/": %m", filename)));			bytes_to_read = fst.st_size - seek_offset;		}	}	/* not sure why anyone thought that int64 length was a good idea */	if (bytes_to_read > (MaxAllocSize - VARHDRSZ))		ereport(ERROR,				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),				 errmsg("requested length too large")));	if ((file = AllocateFile(filename, PG_BINARY_R)) == NULL)		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not open file /"%s/" for reading: %m",						filename)));	if (fseeko(file, (off_t) seek_offset,			   (seek_offset >= 0) ? SEEK_SET : SEEK_END) != 0)		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not seek in file /"%s/": %m", filename)));	buf = (bytea *) palloc((Size) bytes_to_read + VARHDRSZ);	nbytes = fread(VARDATA(buf), 1, (size_t) bytes_to_read, file);	if (ferror(file))		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not read file /"%s/": %m", filename)));	SET_VARSIZE(buf, nbytes + VARHDRSZ);	FreeFile(file);	return buf;}

/* *	Load precomputed DH parameters. * *	To prevent "downgrade" attacks, we perform a number of checks *	to verify that the DBA-generated DH parameters file contains *	what we expect it to contain. */static DH  *load_dh_file(char *filename, bool isServerStart){	FILE	   *fp;	DH		   *dh = NULL;	int			codes;	/* attempt to open file.  It's not an error if it doesn't exist. */	if ((fp = AllocateFile(filename, "r")) == NULL)	{		ereport(isServerStart ? FATAL : LOG,				(errcode_for_file_access(),				 errmsg("could not open DH parameters file /"%s/": %m",						filename)));		return NULL;	}	dh = PEM_read_DHparams(fp, NULL, NULL, NULL);	FreeFile(fp);	if (dh == NULL)	{		ereport(isServerStart ? FATAL : LOG,				(errcode(ERRCODE_CONFIG_FILE_ERROR),				 errmsg("could not load DH parameters file: %s",						SSLerrmessage(ERR_get_error()))));		return NULL;	}	/* make sure the DH parameters are usable */	if (DH_check(dh, &codes) == 0)	{		ereport(isServerStart ? FATAL : LOG,				(errcode(ERRCODE_CONFIG_FILE_ERROR),				 errmsg("invalid DH parameters: %s",						SSLerrmessage(ERR_get_error()))));		return NULL;	}	if (codes & DH_CHECK_P_NOT_PRIME)	{		ereport(isServerStart ? FATAL : LOG,				(errcode(ERRCODE_CONFIG_FILE_ERROR),				 errmsg("invalid DH parameters: p is not prime")));		return NULL;	}	if ((codes & DH_NOT_SUITABLE_GENERATOR) &&		(codes & DH_CHECK_P_NOT_SAFE_PRIME))	{		ereport(isServerStart ? FATAL : LOG,				(errcode(ERRCODE_CONFIG_FILE_ERROR),				 errmsg("invalid DH parameters: neither suitable generator or safe prime")));		return NULL;	}	return dh;}

static voidFileSourceClose(FileSource *self){	if (self->fd != NULL && FreeFile(self->fd) < 0)	{		ereport(WARNING, (errcode_for_file_access(),			errmsg("could not close source file: %m")));	}	pfree(self);}

/* * write out the PG_VERSION file in the specified directory */static voidset_short_version(const char *path){	char	   *short_version;	bool		gotdot = false;	int			end;	char	   *fullname;	FILE	   *version_file;	/* Construct short version string (should match initdb.c) */	short_version = pstrdup(PG_VERSION);	for (end = 0; short_version[end] != '/0'; end++)	{		if (short_version[end] == '.')		{			Assert(end != 0);			if (gotdot)				break;			else				gotdot = true;		}		else if (short_version[end] < '0' || short_version[end] > '9')		{			/* gone past digits and dots */			break;		}	}	Assert(end > 0 && short_version[end - 1] != '.' && gotdot);	short_version[end] = '/0';	/* Now write the file */	fullname = palloc(strlen(path) + 11 + 1);	sprintf(fullname, "%s/PG_VERSION", path);	version_file = AllocateFile(fullname, PG_BINARY_W);	if (version_file == NULL)		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not write to file /"%s/": %m",						fullname)));	fprintf(version_file, "%s/n", short_version);	if (FreeFile(version_file))		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not write to file /"%s/": %m",						fullname)));	pfree(fullname);	pfree(short_version);}

int DoNames(int state) {	int wnum = (int)CurrentWorld;	int lnum = (int)CurrentLevel;		// Skip the title screen	// and only process the code if the State is set to 1	// (the screen has been initialised)	if (state == 1 && lnum != STAGE_TITLE) {		// grab the CRSIN object		Actor *ptr = FindActorByType(CRSIN, 0);				// FIX !!!!!				if (ptr != 0) {			void *worldObj = EmbeddedLayout_FindTextBoxByName((Layout*)((u32)ptr+0xB0), "TXT_WorldName");			void *levelObj = EmbeddedLayout_FindTextBoxByName((Layout*)((u32)ptr+0xB0), "TXT_LevelName");			if (worldObj == 0 || levelObj == 0) return state;						/*char *file = RetrieveFileFromArc(ARC_TABLE, "Mario", "newer/names.bin");			char *worldname = file + (wnum * 0x40);			char *levelname = file + 0x280 + (wnum * 0xA80) + (lnum * 0x40);*/			FileHandle fh;			void *info = LoadFile(&fh, "/NewerRes/LevelInfo.bin");						LevelInfo_Prepare(&fh);			LevelInfo_Entry *entry = LevelInfo_SearchSlot(info, wnum, lnum);			char *worldname = LevelInfo_GetName(info, entry);			char *levelname = "";						void *vtable = *((void**)levelObj);			void *funcaddr = *((void**)((u32)vtable+0x7C));			int (*SetString)(void*, unsigned short*, unsigned short);			SetString = (int(*)(void*, unsigned short*, unsigned short))funcaddr;						unsigned short wbuffer[0x40], lbuffer[0x40];			for (int i = 0; i < 0x40; i++) {				wbuffer[i] = (unsigned short)worldname[i];				lbuffer[i] = (unsigned short)levelname[i];			}						SetString(worldObj, wbuffer, 0);			SetString(levelObj, lbuffer, 0);						FreeFile(&fh);		}	} else {	}		return state;}

voidLoggerClose(void){	if (logger.fp != NULL && FreeFile(logger.fp) < 0)		ereport(WARNING,				(errcode_for_file_access(),				 errmsg("could not close loader log file /"%s/": %m",						logger.logfile)));	if (logger.logfile != NULL)		pfree(logger.logfile);	memset(&logger, 0, sizeof(logger));}

/* Dumps the histogram data into a file (with a md5 hash of the contents at the beginning). */staticvoid query_write(double duration, const char * query, int len, const char * header, int hlen) {        FILE * file;        /* write the buffer first */    buffer_write();        /* now write the query */    prepare_file(log_file, query_buffer, hlen + len);        file = AllocateFile(log_file->curr_filename, PG_BINARY_A);    if (file == NULL)        goto error;        /* now write the actual shared segment */    if (fwrite(header, hlen, 1, file) != 1)       goto error;        /* now write the actual shared segment */    if (fwrite(query, len, 1, file) != 1)       goto error;        FreeFile(file);        return;error:    ereport(LOG,            (errcode_for_file_access(),             errmsg("could not write query to the file /"%s/": %m",                    log_file->curr_filename)));    if (file)        FreeFile(file);    }

/* * Write into the error log file.  This opens the file every time, * so that we can keep it simple to deal with concurrent write. */static voidErrorLogWrite(CdbSreh *cdbsreh){	HeapTuple	tuple;	char		filename[MAXPGPATH];	FILE	   *fp;	pg_crc32	crc;	Assert(OidIsValid(cdbsreh->relid));	ErrorLogFileName(filename, MyDatabaseId, cdbsreh->relid);	tuple = FormErrorTuple(cdbsreh);	INIT_CRC32C(crc);	COMP_CRC32C(crc, tuple->t_data, tuple->t_len);	FIN_CRC32C(crc);	LWLockAcquire(ErrorLogLock, LW_EXCLUSIVE);	fp = AllocateFile(filename, "a");	if (!fp)	{		mkdir(ErrorLogDir, S_IRWXU);		fp = AllocateFile(filename, "a");	}	if (!fp)		ereport(ERROR,				(errmsg("could not open /"%s/": %m", filename)));	/*	 * format:	 *     0-4: length	 *     5-8: crc	 *     9-n: tuple data	 */	if (fwrite(&tuple->t_len, 1, sizeof(tuple->t_len), fp) != sizeof(tuple->t_len))		elog(ERROR, "could not write tuple length: %m");	if (fwrite(&crc, 1, sizeof(pg_crc32), fp) != sizeof(pg_crc32))		elog(ERROR, "could not write checksum: %m");	if (fwrite(tuple->t_data, 1, tuple->t_len, fp) != tuple->t_len)		elog(ERROR, "could not write tuple data: %m");	FreeFile(fp);	LWLockRelease(ErrorLogLock);	heap_freetuple(tuple);}

/* * XLogArchiveForceDone * * Emit notification forcibly that an XLOG segment file has been successfully * archived, by creating <XLOG>.done regardless of whether <XLOG>.ready * exists or not. */voidXLogArchiveForceDone(const char *xlog){	char		archiveReady[MAXPGPATH];	char		archiveDone[MAXPGPATH];	struct stat stat_buf;	FILE	   *fd;	/* Exit if already known done */	StatusFilePath(archiveDone, xlog, ".done");	if (stat(archiveDone, &stat_buf) == 0)		return;	/* If .ready exists, rename it to .done */	StatusFilePath(archiveReady, xlog, ".ready");	if (stat(archiveReady, &stat_buf) == 0)	{		if (rename(archiveReady, archiveDone) < 0)			ereport(WARNING,					(errcode_for_file_access(),					 errmsg("could not rename file /"%s/" to /"%s/": %m",							archiveReady, archiveDone)));		return;	}	/* insert an otherwise empty file called <XLOG>.done */	fd = AllocateFile(archiveDone, "w");	if (fd == NULL)	{		ereport(LOG,				(errcode_for_file_access(),				 errmsg("could not create archive status file /"%s/": %m",						archiveDone)));		return;	}	if (FreeFile(fd))	{		ereport(LOG,				(errcode_for_file_access(),				 errmsg("could not write archive status file /"%s/": %m",						archiveDone)));		return;	}}

voidwrite_nondefault_variables(GucContext context){	int			elevel;	FILE	   *fp;	int			i;	Assert(context == PGC_POSTMASTER || context == PGC_SIGHUP);	elevel = (context == PGC_SIGHUP) ? LOG : ERROR;	/*	 * Open file	 */	fp = AllocateFile(CONFIG_EXEC_PARAMS_NEW, "w");	if (!fp)	{		ereport(elevel,				(errcode_for_file_access(),				 errmsg("could not write to file /"%s/": %m",						CONFIG_EXEC_PARAMS_NEW)));		return;	}	for (i = 0; i < num_guc_variables; i++)	{		write_one_nondefault_variable(fp, guc_variables[i]);	}	if (FreeFile(fp))	{		ereport(elevel,				(errcode_for_file_access(),				 errmsg("could not write to file /"%s/": %m",						CONFIG_EXEC_PARAMS_NEW)));		return;	}	/*	 * Put new file in place.  This could delay on Win32, but we don't hold	 * any exclusive locks.	 */	rename(CONFIG_EXEC_PARAMS_NEW, CONFIG_EXEC_PARAMS);}

Datumpg_file_write(PG_FUNCTION_ARGS){	FILE	   *f;	char	   *filename;	text	   *data;	int64		count = 0;	requireSuperuser();	filename = convert_and_check_filename(PG_GETARG_TEXT_PP(0), false);	data = PG_GETARG_TEXT_PP(1);	if (!PG_GETARG_BOOL(2))	{		struct stat fst;		if (stat(filename, &fst) >= 0)			ereport(ERROR,					(ERRCODE_DUPLICATE_FILE,					 errmsg("file /"%s/" exists", filename)));		f = AllocateFile(filename, "wb");	}	else		f = AllocateFile(filename, "ab");	if (!f)		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not open file /"%s/" for writing: %m",						filename)));	count = fwrite(VARDATA_ANY(data), 1, VARSIZE_ANY_EXHDR(data), f);	if (count != VARSIZE_ANY_EXHDR(data) || FreeFile(f))		ereport(ERROR,				(errcode_for_file_access(),				 errmsg("could not write file /"%s/": %m", filename)));	PG_RETURN_INT64(count);}

static voidAsyncSourceClose(AsyncSource *self){	self->eof = true;	pthread_mutex_unlock(&self->lock);	pthread_join(self->th, NULL);	if (self->fd != NULL && FreeFile(self->fd) < 0)	{		ereport(WARNING, (errcode_for_file_access(),			errmsg("could not close source file: %m")));	}	self->fd = NULL;	if (self->buffer != NULL)		pfree(self->buffer);	self->buffer = NULL;	pfree(self);}

voidSpoolerClose(Spooler *self){	/* Merge indexes */	if (self->spools != NULL)		IndexSpoolEnd(self, true);	/* Terminate spooler. */	ExecDropSingleTupleTableSlot(self->slot);	if (self->estate->es_result_relation_info)		ExecCloseIndices(self->estate->es_result_relation_info);	FreeExecutorState(self->estate);	/* Close and release members. */	if (self->dup_fp != NULL && FreeFile(self->dup_fp) < 0)		ereport(WARNING,				(errcode_for_file_access(),				 errmsg("could not close duplicate bad file /"%s/": %m",						self->dup_badfile)));	if (self->dup_badfile != NULL)		pfree(self->dup_badfile);}

/* Flushes, syncs, and closes the given file pointer and checks for errors. */static voidSyncAndCloseFile(FILE *file){	int flushResult = 0;	int syncResult = 0;	int errorResult = 0;	int freeResult = 0;	errno = 0;	flushResult = fflush(file);	if (flushResult != 0)	{		ereport(ERROR, (errcode_for_file_access(),						errmsg("could not flush file: %m")));	}	syncResult = pg_fsync(fileno(file));	if (syncResult != 0)	{		ereport(ERROR, (errcode_for_file_access(),						errmsg("could not sync file: %m")));	}	errorResult = ferror(file);	if (errorResult != 0)	{		ereport(ERROR, (errcode_for_file_access(),						errmsg("error in file: %m")));	}	freeResult = FreeFile(file);	if (freeResult != 0)	{		ereport(ERROR, (errcode_for_file_access(),						errmsg("could not close file: %m")));	}}

/* * Load rules from the file. * * Parses the pg_limits.conf file and loads all the connection rules that * are defined in it. A syntax error should not result in a failure, * only a WARNING message (and skipping the row). If there are too many * rules in the file (exceeding MAX_RULES), that fails with an ERROR. * * FIXME The current implementation modifies the segment in-place, so *       if a config reload fails, the backends will see the result of *       the failed reload. That's not really nice. This should use a *       local buffer an only copy it in place if everything went OK. * * FIXME The other issue is that we're holding ProcArrayLock while *       parsing the file - at the moment this is necessary because of *       the in-place reload. Once this is fixed, we can hold the lock *       only for the final copy (in case of success). */static voidload_rules(){	FILE   *file;	char	line[LINE_MAXLEN];	char	dbname[NAMEDATALEN], user[NAMEDATALEN], ip[NAMEDATALEN], mask[NAMEDATALEN];	int		limit;	int		line_number = 0;	file = AllocateFile(LIMITS_FILE, "r");	if (file == NULL)	{		ereport(WARNING,				(errcode_for_file_access(),				 errmsg("could not open configuration file /"%s/": %m",						LIMITS_FILE)));		return;	}	/*	 * Use the same lock as when checking the rules (when opening the	 * connection) etc. This is probably the right thing to do.	 */	LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);	/* make sure there are no rules (keep the backend info though) */	memset(rules, 0, RULES_SEGMENT_SIZE);	while (fgets(line, LINE_MAXLEN, file) != NULL)	{		/* remove the comment from the line */		char * comment = strchr(line, '#');		if (comment != NULL)			(*comment) = '/0';		/* remove all white-space chars from the end of the line */		comment--;		while (isspace(comment) && (comment >= line))		{			*comment = '/0';			comment--;		}		++line_number;		/* database user ip mask limit */		if (sscanf(line, "%s %s %s %s %d", dbname, user, ip, mask, &limit) == 5)			load_rule(line_number, dbname, user, ip, mask, limit);		/* database user ip/mask limit */		else if (sscanf(line, "%s %s %s %d", dbname, user, ip, &limit) == 4)			load_rule(line_number, dbname, user, ip, NULL, limit);		/* non-empty line with invalid format */		else if (strlen(line) > 0)			elog(WARNING, "invalid rule at line %d", line_number);	}	FreeFile(file);	LWLockRelease(ProcArrayLock);	elog(DEBUG1, "loaded %d connection limit rule(s)", rules->n_rules);}

//.........这里部分代码省略.........	memset(&info, 0, sizeof(info));	info.keysize = sizeof(pgssHashKey);	info.entrysize = offsetof(pgssEntry, query) +query_size;	info.hash = pgss_hash_fn;	info.match = pgss_match_fn;	pgss_hash = ShmemInitHash("pg_stat_statements hash",							  pgss_max, pgss_max,							  &info,							  HASH_ELEM | HASH_FUNCTION | HASH_COMPARE);	LWLockRelease(AddinShmemInitLock);	/*	 * If we're in the postmaster (or a standalone backend...), set up a shmem	 * exit hook to dump the statistics to disk.	 */	if (!IsUnderPostmaster)		on_shmem_exit(pgss_shmem_shutdown, (Datum) 0);	/*	 * Attempt to load old statistics from the dump file, if this is the first	 * time through and we weren't told not to.	 */	if (found || !pgss_save)		return;	/*	 * Note: we don't bother with locks here, because there should be no other	 * processes running when this code is reached.	 */	file = AllocateFile(PGSS_DUMP_FILE, PG_BINARY_R);	if (file == NULL)	{		if (errno == ENOENT)			return;				/* ignore not-found error */		goto error;	}	buffer_size = query_size;	buffer = (char *) palloc(buffer_size);	if (fread(&header, sizeof(uint32), 1, file) != 1 ||		header != PGSS_FILE_HEADER ||		fread(&num, sizeof(int32), 1, file) != 1)		goto error;	for (i = 0; i < num; i++)	{		pgssEntry	temp;		pgssEntry  *entry;		if (fread(&temp, offsetof(pgssEntry, mutex), 1, file) != 1)			goto error;		/* Encoding is the only field we can easily sanity-check */		if (!PG_VALID_BE_ENCODING(temp.key.encoding))			goto error;		/* Previous incarnation might have had a larger query_size */		if (temp.key.query_len >= buffer_size)		{			buffer = (char *) repalloc(buffer, temp.key.query_len + 1);			buffer_size = temp.key.query_len + 1;		}		if (fread(buffer, 1, temp.key.query_len, file) != temp.key.query_len)			goto error;		buffer[temp.key.query_len] = '/0';		/* Clip to available length if needed */		if (temp.key.query_len >= query_size)			temp.key.query_len = pg_encoding_mbcliplen(temp.key.encoding,													   buffer,													   temp.key.query_len,													   query_size - 1);		temp.key.query_ptr = buffer;		/* make the hashtable entry (discards old entries if too many) */		entry = entry_alloc(&temp.key);		/* copy in the actual stats */		entry->counters = temp.counters;	}	pfree(buffer);	FreeFile(file);	return;error:	ereport(LOG,			(errcode_for_file_access(),			 errmsg("could not read pg_stat_statement file /"%s/": %m",					PGSS_DUMP_FILE)));	if (buffer)		pfree(buffer);	if (file)		FreeFile(file);	/* If possible, throw away the bogus file; ignore any error */	unlink(PGSS_DUMP_FILE);}

/* * ImportSnapshot *      Import a previously exported snapshot.  The argument should be a *      filename in SNAPSHOT_EXPORT_DIR.  Load the snapshot from that file. *      This is called by "SET TRANSACTION SNAPSHOT 'foo'". */voidImportSnapshot(const char *idstr){	char		path[MAXPGPATH];	FILE	   *f;	struct stat	stat_buf;	char	   *filebuf;	int			xcnt;	int			i;	TransactionId src_xid;	Oid			src_dbid;	int			src_isolevel;	bool		src_readonly;	SnapshotData snapshot;	/*	 * Must be at top level of a fresh transaction.  Note in particular that	 * we check we haven't acquired an XID --- if we have, it's conceivable	 * that the snapshot would show it as not running, making for very	 * screwy behavior.	 */	if (FirstSnapshotSet ||		GetTopTransactionIdIfAny() != InvalidTransactionId ||		IsSubTransaction())		ereport(ERROR,				(errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),				 errmsg("SET TRANSACTION SNAPSHOT must be called before any query")));	/*	 * If we are in read committed mode then the next query would execute	 * with a new snapshot thus making this function call quite useless.	 */	if (!IsolationUsesXactSnapshot())		ereport(ERROR,				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),				 errmsg("a snapshot-importing transaction must have isolation level SERIALIZABLE or REPEATABLE READ")));	/*	 * Verify the identifier: only 0-9, A-F and hyphens are allowed.  We do	 * this mainly to prevent reading arbitrary files.	 */	if (strspn(idstr, "0123456789ABCDEF-") != strlen(idstr))		ereport(ERROR,				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),				 errmsg("invalid snapshot identifier /"%s/"", idstr)));	/* OK, read the file */	snprintf(path, MAXPGPATH, SNAPSHOT_EXPORT_DIR "/%s", idstr);	f = AllocateFile(path, PG_BINARY_R);	if (!f)		ereport(ERROR,				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),				 errmsg("invalid snapshot identifier /"%s/"", idstr)));	/* get the size of the file so that we know how much memory we need */	if (fstat(fileno(f), &stat_buf))		elog(ERROR, "could not stat file /"%s/": %m", path);	/* and read the file into a palloc'd string */	filebuf = (char *) palloc(stat_buf.st_size + 1);	if (fread(filebuf, stat_buf.st_size, 1, f) != 1)		elog(ERROR, "could not read file /"%s/": %m", path);	filebuf[stat_buf.st_size] = '/0';	FreeFile(f);	/*	 * Construct a snapshot struct by parsing the file content.	 */	memset(&snapshot, 0, sizeof(snapshot));	src_xid = parseXidFromText("xid:", &filebuf, path);	/* we abuse parseXidFromText a bit here ... */	src_dbid = parseXidFromText("dbid:", &filebuf, path);	src_isolevel = parseIntFromText("iso:", &filebuf, path);	src_readonly = parseIntFromText("ro:", &filebuf, path);	snapshot.xmin = parseXidFromText("xmin:", &filebuf, path);	snapshot.xmax = parseXidFromText("xmax:", &filebuf, path);	snapshot.xcnt = xcnt = parseIntFromText("xcnt:", &filebuf, path);	/* sanity-check the xid count before palloc */	if (xcnt < 0 || xcnt > GetMaxSnapshotXidCount())		ereport(ERROR,				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),				 errmsg("invalid snapshot data in file /"%s/"", path)));	snapshot.xip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));	for (i = 0; i < xcnt; i++)		snapshot.xip[i] = parseXidFromText("xip:", &filebuf, path);//.........这里部分代码省略.........