(errcode_for_file_access(),
errmsg("could not write file \"%s\": %m",
PGSS_DUMP_FILE ".tmp")));
- if (qbuffer)
- free(qbuffer);
+ free(qbuffer);
if (file)
FreeFile(file);
unlink(PGSS_DUMP_FILE ".tmp");
pgss->extent != extent ||
pgss->gc_count != gc_count)
{
- if (qbuffer)
- free(qbuffer);
+ free(qbuffer);
qbuffer = qtext_load_file(&qbuffer_size);
}
}
LWLockRelease(pgss->lock);
- if (qbuffer)
- free(qbuffer);
+ free(qbuffer);
}
/* Number of output arguments (columns) for pg_stat_statements_info */
/* clean up resources */
if (qfile)
FreeFile(qfile);
- if (qbuffer)
- free(qbuffer);
+ free(qbuffer);
/*
* Since the contents of the external file are now uncertain, mark all
if (ptr && len <= 36)
strcpy(strbuf + (36 - len), ptr);
}
- if (str)
- free(str);
+ free(str);
}
if (status != uuid_s_ok)
if (status == uuid_s_ok)
strlcpy(strbuf, str, 37);
- if (str)
- free(str);
+ free(str);
if (status != uuid_s_ok)
ereport(ERROR,
SetConfigOption(name, value, PGC_POSTMASTER, PGC_S_ARGV);
free(name);
- if (value)
- free(value);
+ free(value);
break;
}
default:
fail:
/* free up whatever we allocated */
for (i = 0; i < num_msg; i++)
- {
- if (reply[i].resp != NULL)
- free(reply[i].resp);
- }
+ free(reply[i].resp);
free(reply);
return PAM_CONV_ERR;
SetConfigOption(name, value, PGC_POSTMASTER, PGC_S_ARGV);
free(name);
- if (value)
- free(value);
+ free(value);
break;
}
* Failure, clean up
*/
out_of_memory:
- if (pcc->cv.chrs)
- free(pcc->cv.chrs);
- if (pcc->cv.ranges)
- free(pcc->cv.ranges);
+ free(pcc->cv.chrs);
+ free(pcc->cv.ranges);
free(pcc);
return NULL;
}
SetConfigOption(name, value, ctx, gucsource);
free(name);
- if (value)
- free(value);
+ free(value);
break;
}
static void
free_struct_lconv(struct lconv *s)
{
- if (s->decimal_point)
- free(s->decimal_point);
- if (s->thousands_sep)
- free(s->thousands_sep);
- if (s->grouping)
- free(s->grouping);
- if (s->int_curr_symbol)
- free(s->int_curr_symbol);
- if (s->currency_symbol)
- free(s->currency_symbol);
- if (s->mon_decimal_point)
- free(s->mon_decimal_point);
- if (s->mon_thousands_sep)
- free(s->mon_thousands_sep);
- if (s->mon_grouping)
- free(s->mon_grouping);
- if (s->positive_sign)
- free(s->positive_sign);
- if (s->negative_sign)
- free(s->negative_sign);
+ free(s->decimal_point);
+ free(s->thousands_sep);
+ free(s->grouping);
+ free(s->int_curr_symbol);
+ free(s->currency_symbol);
+ free(s->mon_decimal_point);
+ free(s->mon_thousands_sep);
+ free(s->mon_grouping);
+ free(s->positive_sign);
+ free(s->negative_sign);
}
/*
closelog();
openlog_done = false;
}
- if (syslog_ident)
- free(syslog_ident);
+ free(syslog_ident);
syslog_ident = strdup(ident);
/* if the strdup fails, we will cope in write_syslog() */
syslog_facility = facility;
/* If presented path is relative, convert to absolute */
new = make_absolute_path(dir);
- if (DataDir)
- free(DataDir);
+ free(DataDir);
DataDir = new;
}
for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
guc_vars[num_vars++] = &ConfigureNamesEnum[i].gen;
- if (guc_variables)
- free(guc_variables);
+ free(guc_variables);
guc_variables = guc_vars;
num_guc_variables = num_vars;
size_guc_variables = size_vars;
* set last_reported to NULL and thereby possibly make a duplicate
* report later.
*/
- if (record->last_reported)
- free(record->last_reported);
+ free(record->last_reported);
record->last_reported = strdup(val);
}
return;
sourcefile = guc_strdup(elevel, sourcefile);
- if (record->sourcefile)
- free(record->sourcefile);
+ free(record->sourcefile);
record->sourcefile = sourcefile;
record->sourceline = sourceline;
}
if (record->vartype == PGC_STRING && newval.stringval != NULL)
free(newval.stringval);
- if (newextra)
- free(newextra);
+ free(newextra);
/*
* We must also reject values containing newlines, because the
* pointers.
*/
Assert(gconf->stack == NULL);
- if (gconf->extra)
- free(gconf->extra);
- if (gconf->last_reported) /* probably can't happen */
- free(gconf->last_reported);
- if (gconf->sourcefile)
- free(gconf->sourcefile);
+ free(gconf->extra);
+ free(gconf->last_reported);
+ free(gconf->sourcefile);
switch (gconf->vartype)
{
case PGC_BOOL:
{
struct config_string *conf = (struct config_string *) gconf;
- if (*conf->variable)
- free(*conf->variable);
+ free(*conf->variable);
if (conf->reset_val && conf->reset_val != *conf->variable)
free(conf->reset_val);
if (conf->reset_extra && conf->reset_extra != gconf->extra)
/* We needn't maintain this variable if not doing verbose reports. */
if (showprogress && verbose)
{
- if (progress_filename)
- free(progress_filename);
+ free(progress_filename);
if (filename)
progress_filename = pg_strdup(filename);
else
/* Get a new password if appropriate */
if (need_password)
{
- if (password)
- free(password);
+ free(password);
password = simple_prompt("Password: ", false);
need_password = false;
}
/* Parse the acls array */
if (!parsePGArray(acls, &aclitems, &naclitems))
{
- if (aclitems)
- free(aclitems);
+ free(aclitems);
return false;
}
/* Parse the baseacls too */
if (!parsePGArray(baseacls, &baseitems, &nbaseitems))
{
- if (aclitems)
- free(aclitems);
- if (baseitems)
- free(baseitems);
+ free(aclitems);
+ free(baseitems);
return false;
}
destroyPQExpBuffer(firstsql);
destroyPQExpBuffer(secondsql);
- if (aclitems)
- free(aclitems);
- if (baseitems)
- free(baseitems);
- if (grantitems)
- free(grantitems);
- if (revokeitems)
- free(revokeitems);
+ free(aclitems);
+ free(baseitems);
+ free(grantitems);
+ free(revokeitems);
return ok;
}
* If we treated users as pg_dump'able objects then we'd need to reset
* currUser here too.
*/
- if (AH->currSchema)
- free(AH->currSchema);
+ free(AH->currSchema);
AH->currSchema = NULL;
}
pg_log_debug("attempting to ascertain archive format");
- if (AH->lookahead)
- free(AH->lookahead);
+ free(AH->lookahead);
AH->readHeader = 0;
AH->lookaheadSize = 512;
* NOTE: currUser keeps track of what the imaginary session user in our
* script is. It's now effectively reset to the original userID.
*/
- if (AH->currUser)
- free(AH->currUser);
+ free(AH->currUser);
AH->currUser = NULL;
/* don't assume we still know the output schema, tablespace, etc either */
- if (AH->currSchema)
- free(AH->currSchema);
+ free(AH->currSchema);
AH->currSchema = NULL;
- if (AH->currTableAm)
- free(AH->currTableAm);
+ free(AH->currTableAm);
AH->currTableAm = NULL;
- if (AH->currTablespace)
- free(AH->currTablespace);
+ free(AH->currTablespace);
AH->currTablespace = NULL;
/* re-establish fixed state */
* NOTE: currUser keeps track of what the imaginary session user in our
* script is
*/
- if (AH->currUser)
- free(AH->currUser);
+ free(AH->currUser);
AH->currUser = pg_strdup(user);
}
else
ahprintf(AH, "%s;\n\n", qry->data);
- if (AH->currSchema)
- free(AH->currSchema);
+ free(AH->currSchema);
AH->currSchema = pg_strdup(schemaName);
destroyPQExpBuffer(qry);
else
ahprintf(AH, "%s;\n\n", qry->data);
- if (AH->currTablespace)
- free(AH->currTablespace);
+ free(AH->currTablespace);
AH->currTablespace = pg_strdup(want);
destroyPQExpBuffer(qry);
destroyPQExpBuffer(cmd);
- if (AH->currTableAm)
- free(AH->currTableAm);
+ free(AH->currTableAm);
AH->currTableAm = pg_strdup(want);
}
*/
if (_tocEntryIsACL(te))
{
- if (AH->currUser)
- free(AH->currUser);
+ free(AH->currUser);
AH->currUser = NULL;
}
}
DisconnectDatabase(&AH->public);
/* blow away any transient state from the old connection */
- if (AH->currUser)
- free(AH->currUser);
+ free(AH->currUser);
AH->currUser = NULL;
- if (AH->currSchema)
- free(AH->currSchema);
+ free(AH->currSchema);
AH->currSchema = NULL;
- if (AH->currTablespace)
- free(AH->currTablespace);
+ free(AH->currTablespace);
AH->currTablespace = NULL;
- if (AH->currTableAm)
- free(AH->currTableAm);
+ free(AH->currTableAm);
AH->currTableAm = NULL;
}
destroyPQExpBuffer(AH->sqlparse.curCmd);
/* Clear any connection-local state */
- if (AH->currUser)
- free(AH->currUser);
- if (AH->currSchema)
- free(AH->currSchema);
- if (AH->currTablespace)
- free(AH->currTablespace);
- if (AH->currTableAm)
- free(AH->currTableAm);
- if (AH->savedPassword)
- free(AH->savedPassword);
+ free(AH->currUser);
+ free(AH->currSchema);
+ free(AH->currTablespace);
+ free(AH->currTableAm);
+ free(AH->savedPassword);
free(AH);
}
{
if (blkLen > buflen)
{
- if (buf)
- free(buf);
+ free(buf);
buf = (char *) pg_malloc(blkLen);
buflen = blkLen;
}
blkLen = ReadInt(AH);
}
- if (buf)
- free(buf);
+ free(buf);
}
/*
*/
if (PQconnectionUsedPassword(AH->connection))
{
- if (AH->savedPassword)
- free(AH->savedPassword);
+ free(AH->savedPassword);
AH->savedPassword = pg_strdup(PQpass(AH->connection));
}
* handle, and we don't use temp files.
*/
- if (th->targetFile)
- free(th->targetFile);
+ free(th->targetFile);
th->nFH = NULL;
}
/* Also save it in AH->searchpath, in case we're doing plain text dump */
AH->searchpath = pg_strdup(qry->data);
- if (schemanames)
- free(schemanames);
+ free(schemanames);
PQclear(res);
destroyPQExpBuffer(qry);
destroyPQExpBuffer(path);
subinfo->dobj.catId, 0, subinfo->dobj.dumpId);
destroyPQExpBuffer(publications);
- if (pubnames)
- free(pubnames);
+ free(pubnames);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
destroyPQExpBuffer(delqry);
destroyPQExpBuffer(asPart);
free(funcsig);
- if (funcfullsig)
- free(funcfullsig);
+ free(funcfullsig);
free(funcsig_tag);
free(qual_funcsig);
- if (configitems)
- free(configitems);
+ free(configitems);
}
agginfo->aggfn.rolname, &agginfo->aggfn.dacl);
free(aggsig);
- if (aggfullsig)
- free(aggfullsig);
+ free(aggfullsig);
free(aggsig_tag);
PQclear(res);
tbinfo->attfdwoptions[j]);
} /* end loop over columns */
- if (partkeydef)
- free(partkeydef);
- if (ftoptions)
- free(ftoptions);
- if (srvname)
- free(srvname);
+ free(partkeydef);
+ free(ftoptions);
+ free(srvname);
}
/*
.createStmt = q->data,
.dropStmt = delq->data));
- if (indstatcolsarray)
- free(indstatcolsarray);
- if (indstatvalsarray)
- free(indstatvalsarray);
+ free(indstatcolsarray);
+ free(indstatvalsarray);
}
/* Dump Index Comments */
char *err_msg = NULL;
int i = 0;
- if (keywords)
- free(keywords);
- if (values)
- free(values);
+ free(keywords);
+ free(values);
if (conn_opts)
PQconninfoFree(conn_opts);
/* dup then free, in case value is pointing at this variable */
val = pg_strdup(value);
- if (var->svalue)
- free(var->svalue);
+ free(var->svalue);
var->svalue = val;
var->value.type = PGBT_NO_VALUE;
if (!var)
return false;
- if (var->svalue)
- free(var->svalue);
+ free(var->svalue);
var->svalue = NULL;
var->value = *value;
success = false;
}
- if (opt)
- free(opt);
+ free(opt);
}
else
ignore_slash_options(scan_state);
break;
}
- if (pattern2)
- free(pattern2);
+ free(pattern2);
}
break;
case 'a':
OT_NORMAL, NULL, true);
success = listDbRoleSettings(pattern, pattern2);
- if (pattern2)
- free(pattern2);
+ free(pattern2);
}
else
status = PSQL_CMD_UNKNOWN;
status = PSQL_CMD_UNKNOWN;
}
- if (pattern)
- free(pattern);
+ free(pattern);
}
else
ignore_slash_options(scan_state);
else
status = PSQL_CMD_ERROR;
}
- if (fname)
- free(fname);
- if (ln)
- free(ln);
+ free(fname);
+ free(ln);
}
}
else
status = PSQL_CMD_NEWEDIT;
}
- if (obj_desc)
- free(obj_desc);
+ free(obj_desc);
}
else
ignore_slash_whole_line(scan_state);
success = listAllDbs(pattern, show_verbose);
- if (pattern)
- free(pattern);
+ free(pattern);
}
else
ignore_slash_options(scan_state);
}
free(user);
- if (pw1)
- free(pw1);
- if (pw2)
- free(pw2);
+ free(pw1);
+ free(pw2);
termPQExpBuffer(&buf);
}
else
(result && !SetVariable(pset.vars, opt, result)))
success = false;
- if (result)
- free(result);
- if (prompt_text)
- free(prompt_text);
+ free(result);
+ free(prompt_text);
free(opt);
}
}
ClosePager(output);
}
- if (obj_desc)
- free(obj_desc);
+ free(obj_desc);
destroyPQExpBuffer(buf);
}
else
OT_NORMAL, NULL, true);
success = permissionsList(pattern);
- if (pattern)
- free(pattern);
+ free(pattern);
}
else
ignore_slash_options(scan_state);
else
slashUsage(pset.popt.topt.pager);
- if (opt0)
- free(opt0);
+ free(opt0);
}
else
ignore_slash_options(scan_state);
char *arg = psql_scan_slash_option(scan_state,
OT_FILEPIPE, NULL, false);
- if (arg)
- free(arg);
+ free(arg);
}
/*
char *arg = psql_scan_slash_option(scan_state,
OT_WHOLE_LINE, NULL, false);
- if (arg)
- free(arg);
+ free(arg);
}
/*
/* Free all the old data we're about to overwrite the pointers to. */
/* topt.line_style points to const data that need not be duplicated */
- if (popt->topt.fieldSep.separator)
- free(popt->topt.fieldSep.separator);
- if (popt->topt.recordSep.separator)
- free(popt->topt.recordSep.separator);
- if (popt->topt.tableAttr)
- free(popt->topt.tableAttr);
- if (popt->nullPrint)
- free(popt->nullPrint);
- if (popt->title)
- free(popt->title);
+ free(popt->topt.fieldSep.separator);
+ free(popt->topt.recordSep.separator);
+ free(popt->topt.tableAttr);
+ free(popt->nullPrint);
+ free(popt->title);
/*
* footers and translate_columns are never set in psql's print settings,
pg_log_error("%s: %s", options->file,
reason ? reason : "");
- if (reason)
- free(reason);
+ free(reason);
}
success = false;
}
printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
- if (footers[0])
- free(footers[0]);
+ free(footers[0]);
retval = true;
goto error_return; /* not an error, just return early */
termPQExpBuffer(&title);
termPQExpBuffer(&tmpbuf);
- if (view_def)
- free(view_def);
+ free(view_def);
if (res)
PQclear(res);
else
{
/* Save each previous line for ignoredups processing */
- if (prev_hist)
- free(prev_hist);
+ free(prev_hist);
prev_hist = pg_strdup(s);
/* And send it to readline */
add_history(s);
free(previous_words);
free(words_buffer);
free(text_copy);
- if (completion_ref_object)
- free(completion_ref_object);
+ free(completion_ref_object);
completion_ref_object = NULL;
- if (completion_ref_schema)
- free(completion_ref_schema);
+ free(completion_ref_schema);
completion_ref_schema = NULL;
/* Return our Grand List O' Matches */
/* Clean up */
termPQExpBuffer(&query_buffer);
free(e_object_like);
- if (e_schemaname)
- free(e_schemaname);
- if (e_ref_object)
- free(e_ref_object);
- if (e_ref_schema)
- free(e_ref_schema);
+ free(e_schemaname);
+ free(e_ref_object);
+ free(e_ref_schema);
}
/* Return the next result, if any, but not if the query failed */
void
pg_free(void *ptr)
{
- if (ptr != NULL)
- free(ptr);
+ free(ptr);
}
/*
cparams->prompt_password != TRI_NO)
{
PQfinish(conn);
- if (password)
- free(password);
+ free(password);
password = simple_prompt("Password: ", false);
new_pass = true;
}
if (!parsePGArray(reloptions, &options, &noptions))
{
- if (options)
- free(options);
+ free(options);
return false;
}
appendStringLiteral(buffer, value, encoding, std_strings);
}
- if (options)
- free(options);
+ free(options);
return true;
}
#define init_var(v) memset(v,0,sizeof(numeric))
#define digitbuf_alloc(size) ((NumericDigit *) pgtypes_alloc(size))
-#define digitbuf_free(buf) \
- do { \
- if ((buf) != NULL) \
- free(buf); \
- } while (0)
+#define digitbuf_free(buf) free(buf)
/* ----------
&& strcmp(connection, i->connection) == 0))
{
*lastptr = i->next;
- if (i->connection)
- free(i->connection);
+ free(i->connection);
free(i->name);
free(i);
return;
{
fe_scram_state *state = (fe_scram_state *) opaq;
- if (state->password)
- free(state->password);
- if (state->sasl_mechanism)
- free(state->sasl_mechanism);
+ free(state->password);
+ free(state->sasl_mechanism);
/* client messages */
- if (state->client_nonce)
- free(state->client_nonce);
- if (state->client_first_message_bare)
- free(state->client_first_message_bare);
- if (state->client_final_message_without_proof)
- free(state->client_final_message_without_proof);
+ free(state->client_nonce);
+ free(state->client_first_message_bare);
+ free(state->client_final_message_without_proof);
/* first message from server */
- if (state->server_first_message)
- free(state->server_first_message);
- if (state->salt)
- free(state->salt);
- if (state->nonce)
- free(state->nonce);
+ free(state->server_first_message);
+ free(state->salt);
+ free(state->nonce);
/* final message from server */
- if (state->server_final_message)
- free(state->server_final_message);
+ free(state->server_final_message);
free(state);
}
if (!pg_strong_random(saltbuf, SCRAM_DEFAULT_SALT_LEN))
{
*errstr = _("failed to generate random salt");
- if (prep_password)
- free(prep_password);
+ free(prep_password);
return NULL;
}
SCRAM_DEFAULT_ITERATIONS, password,
errstr);
- if (prep_password)
- free(prep_password);
+ free(prep_password);
return result;
}
NULL,
NULL);
- if (ginbuf.value)
- free(ginbuf.value);
+ free(ginbuf.value);
if (goutbuf.length != 0)
{
NULL);
/* we don't need the input anymore */
- if (inputbuf)
- free(inputbuf);
+ free(inputbuf);
if (r != SEC_E_OK && r != SEC_I_CONTINUE_NEEDED)
{
goto error;
termPQExpBuffer(&mechanism_buf);
- if (initialresponse)
- free(initialresponse);
+ free(initialresponse);
return STATUS_OK;
error:
termPQExpBuffer(&mechanism_buf);
- if (initialresponse)
- free(initialresponse);
+ free(initialresponse);
return STATUS_ERROR;
oom_error:
termPQExpBuffer(&mechanism_buf);
- if (initialresponse)
- free(initialresponse);
+ free(initialresponse);
appendPQExpBufferStr(&conn->errorMessage,
libpq_gettext("out of memory\n"));
return STATUS_ERROR;
return STATUS_ERROR;
}
ret = pqPacketSend(conn, 'p', pwd_to_send, strlen(pwd_to_send) + 1);
- if (crypt_pwd)
- free(crypt_pwd);
+ free(crypt_pwd);
return ret;
}
PGcmdQueueEntry *cur = queue;
queue = cur->next;
- if (cur->query)
- free(cur->query);
+ free(cur->query);
free(cur);
}
}
conn->sversion = 0;
/* Drop large-object lookup data */
- if (conn->lobjfuncs)
- free(conn->lobjfuncs);
+ free(conn->lobjfuncs);
conn->lobjfuncs = NULL;
/* Reset assorted other per-connection state */
conn->auth_req_received = false;
conn->password_needed = false;
conn->write_failed = false;
- if (conn->write_err_msg)
- free(conn->write_err_msg);
+ free(conn->write_err_msg);
conn->write_err_msg = NULL;
conn->be_pid = 0;
conn->be_key = 0;
{
char **connmember = (char **) ((char *) conn + option->connofs);
- if (*connmember)
- free(*connmember);
+ free(*connmember);
*connmember = strdup(tmp);
if (*connmember == NULL)
{
}
else
{
- if (ch->host)
- free(ch->host);
+ free(ch->host);
/*
* This bit selects the default host location. If you change
*/
if (conn->pguser == NULL || conn->pguser[0] == '\0')
{
- if (conn->pguser)
- free(conn->pguser);
+ free(conn->pguser);
conn->pguser = pg_fe_getauthname(&conn->errorMessage);
if (!conn->pguser)
{
*/
if (conn->dbName == NULL || conn->dbName[0] == '\0')
{
- if (conn->dbName)
- free(conn->dbName);
+ free(conn->dbName);
conn->dbName = strdup(conn->pguser);
if (!conn->dbName)
goto oom_error;
if (pqGetHomeDirectory(homedir, sizeof(homedir)))
{
- if (conn->pgpassfile)
- free(conn->pgpassfile);
+ free(conn->pgpassfile);
conn->pgpassfile = malloc(MAXPGPATH);
if (!conn->pgpassfile)
goto oom_error;
/* Insert dbName parameter value into struct */
if (dbName && dbName[0] != '\0')
{
- if (conn->dbName)
- free(conn->dbName);
+ free(conn->dbName);
conn->dbName = strdup(dbName);
if (!conn->dbName)
goto oom_error;
*/
if (pghost && pghost[0] != '\0')
{
- if (conn->pghost)
- free(conn->pghost);
+ free(conn->pghost);
conn->pghost = strdup(pghost);
if (!conn->pghost)
goto oom_error;
if (pgport && pgport[0] != '\0')
{
- if (conn->pgport)
- free(conn->pgport);
+ free(conn->pgport);
conn->pgport = strdup(pgport);
if (!conn->pgport)
goto oom_error;
if (pgoptions && pgoptions[0] != '\0')
{
- if (conn->pgoptions)
- free(conn->pgoptions);
+ free(conn->pgoptions);
conn->pgoptions = strdup(pgoptions);
if (!conn->pgoptions)
goto oom_error;
if (login && login[0] != '\0')
{
- if (conn->pguser)
- free(conn->pguser);
+ free(conn->pguser);
conn->pguser = strdup(login);
if (!conn->pguser)
goto oom_error;
if (pwd && pwd[0] != '\0')
{
- if (conn->pgpass)
- free(conn->pgpass);
+ free(conn->pgpass);
conn->pgpass = strdup(pwd);
if (!conn->pgpass)
goto oom_error;
static void
freePGconn(PGconn *conn)
{
- int i;
-
/* let any event procs clean up their state data */
- for (i = 0; i < conn->nEvents; i++)
+ for (int i = 0; i < conn->nEvents; i++)
{
PGEventConnDestroy evt;
}
/* clean up pg_conn_host structures */
- if (conn->connhost != NULL)
+ for (int i = 0; i < conn->nconnhost; ++i)
{
- for (i = 0; i < conn->nconnhost; ++i)
+ free(conn->connhost[i].host);
+ free(conn->connhost[i].hostaddr);
+ free(conn->connhost[i].port);
+ if (conn->connhost[i].password != NULL)
{
- if (conn->connhost[i].host != NULL)
- free(conn->connhost[i].host);
- if (conn->connhost[i].hostaddr != NULL)
- free(conn->connhost[i].hostaddr);
- if (conn->connhost[i].port != NULL)
- free(conn->connhost[i].port);
- if (conn->connhost[i].password != NULL)
- {
- explicit_bzero(conn->connhost[i].password, strlen(conn->connhost[i].password));
- free(conn->connhost[i].password);
- }
+ explicit_bzero(conn->connhost[i].password, strlen(conn->connhost[i].password));
+ free(conn->connhost[i].password);
}
- free(conn->connhost);
}
-
- if (conn->client_encoding_initial)
- free(conn->client_encoding_initial);
- if (conn->events)
- free(conn->events);
- if (conn->pghost)
- free(conn->pghost);
- if (conn->pghostaddr)
- free(conn->pghostaddr);
- if (conn->pgport)
- free(conn->pgport);
- if (conn->connect_timeout)
- free(conn->connect_timeout);
- if (conn->pgtcp_user_timeout)
- free(conn->pgtcp_user_timeout);
- if (conn->pgoptions)
- free(conn->pgoptions);
- if (conn->appname)
- free(conn->appname);
- if (conn->fbappname)
- free(conn->fbappname);
- if (conn->dbName)
- free(conn->dbName);
- if (conn->replication)
- free(conn->replication);
- if (conn->pguser)
- free(conn->pguser);
+ free(conn->connhost);
+
+ free(conn->client_encoding_initial);
+ free(conn->events);
+ free(conn->pghost);
+ free(conn->pghostaddr);
+ free(conn->pgport);
+ free(conn->connect_timeout);
+ free(conn->pgtcp_user_timeout);
+ free(conn->pgoptions);
+ free(conn->appname);
+ free(conn->fbappname);
+ free(conn->dbName);
+ free(conn->replication);
+ free(conn->pguser);
if (conn->pgpass)
{
explicit_bzero(conn->pgpass, strlen(conn->pgpass));
free(conn->pgpass);
}
- if (conn->pgpassfile)
- free(conn->pgpassfile);
- if (conn->channel_binding)
- free(conn->channel_binding);
- if (conn->keepalives)
- free(conn->keepalives);
- if (conn->keepalives_idle)
- free(conn->keepalives_idle);
- if (conn->keepalives_interval)
- free(conn->keepalives_interval);
- if (conn->keepalives_count)
- free(conn->keepalives_count);
- if (conn->sslmode)
- free(conn->sslmode);
- if (conn->sslcert)
- free(conn->sslcert);
- if (conn->sslkey)
- free(conn->sslkey);
+ free(conn->pgpassfile);
+ free(conn->channel_binding);
+ free(conn->keepalives);
+ free(conn->keepalives_idle);
+ free(conn->keepalives_interval);
+ free(conn->keepalives_count);
+ free(conn->sslmode);
+ free(conn->sslcert);
+ free(conn->sslkey);
if (conn->sslpassword)
{
explicit_bzero(conn->sslpassword, strlen(conn->sslpassword));
free(conn->sslpassword);
}
- if (conn->sslrootcert)
- free(conn->sslrootcert);
- if (conn->sslcrl)
- free(conn->sslcrl);
- if (conn->sslcrldir)
- free(conn->sslcrldir);
- if (conn->sslcompression)
- free(conn->sslcompression);
- if (conn->sslsni)
- free(conn->sslsni);
- if (conn->requirepeer)
- free(conn->requirepeer);
- if (conn->ssl_min_protocol_version)
- free(conn->ssl_min_protocol_version);
- if (conn->ssl_max_protocol_version)
- free(conn->ssl_max_protocol_version);
- if (conn->gssencmode)
- free(conn->gssencmode);
- if (conn->krbsrvname)
- free(conn->krbsrvname);
- if (conn->gsslib)
- free(conn->gsslib);
- if (conn->connip)
- free(conn->connip);
+ free(conn->sslrootcert);
+ free(conn->sslcrl);
+ free(conn->sslcrldir);
+ free(conn->sslcompression);
+ free(conn->sslsni);
+ free(conn->requirepeer);
+ free(conn->ssl_min_protocol_version);
+ free(conn->ssl_max_protocol_version);
+ free(conn->gssencmode);
+ free(conn->krbsrvname);
+ free(conn->gsslib);
+ free(conn->connip);
/* Note that conn->Pfdebug is not ours to close or free */
- if (conn->write_err_msg)
- free(conn->write_err_msg);
- if (conn->inBuffer)
- free(conn->inBuffer);
- if (conn->outBuffer)
- free(conn->outBuffer);
- if (conn->rowBuf)
- free(conn->rowBuf);
- if (conn->target_session_attrs)
- free(conn->target_session_attrs);
+ free(conn->write_err_msg);
+ free(conn->inBuffer);
+ free(conn->outBuffer);
+ free(conn->rowBuf);
+ free(conn->target_session_attrs);
termPQExpBuffer(&conn->errorMessage);
termPQExpBuffer(&conn->workBuffer);
void
PQfreeCancel(PGcancel *cancel)
{
- if (cancel)
- free(cancel);
+ free(cancel);
}
{
if (strcmp(options[k].keyword, str_option->keyword) == 0)
{
- if (options[k].val)
- free(options[k].val);
+ free(options[k].val);
options[k].val = strdup(str_option->val);
if (!options[k].val)
{
/*
* Store the value, overriding previous settings
*/
- if (option->val)
- free(option->val);
+ free(option->val);
option->val = strdup(pvalue);
if (!option->val)
{
cleanup:
termPQExpBuffer(&hostbuf);
termPQExpBuffer(&portbuf);
- if (buf)
- free(buf);
+ free(buf);
return retval;
}
}
}
- if (option->val)
- free(option->val);
+ free(option->val);
option->val = value_copy;
return option;
void
PQconninfoFree(PQconninfoOption *connOptions)
{
- PQconninfoOption *option;
-
if (connOptions == NULL)
return;
- for (option = connOptions; option->keyword != NULL; option++)
- {
- if (option->val != NULL)
- free(option->val);
- }
+ for (PQconninfoOption *option = connOptions; option->keyword != NULL; option++)
+ free(option->val);
free(connOptions);
}
free(res->events[i].name);
}
- if (res->events)
- free(res->events);
+ free(res->events);
/* Free all the subsidiary blocks */
while ((block = res->curBlock) != NULL)
}
/* Free the top-level tuple pointer array */
- if (res->tuples)
- free(res->tuples);
+ free(res->tuples);
/* zero out the pointer fields to catch programming errors */
res->attDescs = NULL;
fputs("</table>\n", fout);
exit:
- if (fieldMax)
- free(fieldMax);
- if (fieldNotNum)
- free(fieldNotNum);
- if (border)
- free(border);
+ free(fieldMax);
+ free(fieldNotNum);
+ free(border);
if (fields)
{
/* if calloc succeeded, this shouldn't overflow size_t */
size_t numfields = ((size_t) nTups + 1) * (size_t) nFields;
while (numfields-- > 0)
- {
- if (fields[numfields])
- free(fields[numfields]);
- }
+ free(fields[numfields]);
free(fields);
}
- if (fieldNames)
- free((void *) fieldNames);
+ free(fieldNames);
if (usePipe)
{
#ifdef WIN32
fflush(fp);
- if (fLength)
- free(fLength);
+ free(fLength);
}
}
}
- if (tborder)
- free(tborder);
+ free(tborder);
}
}
/* clean up */
- if (first_name)
- free(first_name);
+ free(first_name);
return (rc == 1);
}
}
#endif
- if (res->ai_addr)
- free(res->ai_addr);
+ free(res->ai_addr);
free(res);
}
}
projects / users / c2main / postgres.git / commitdiff