#include <string.h>
#include "checksig.h"
+#include "intl.h"
#include "rpmlib.h"
#include "rpmlead.h"
#include "signature.h"
rpm = *argv++;
printf("%s:\n", rpm);
if ((fd = open(rpm, O_RDONLY, 0644)) < 0) {
- fprintf(stderr, "%s: Open failed\n", rpm);
+ fprintf(stderr, _("%s: Open failed\n"), rpm);
exit(1);
}
if (readLead(fd, &lead)) {
- fprintf(stderr, "%s: readLead failed\n", rpm);
+ fprintf(stderr, _("%s: readLead failed\n"), rpm);
exit(1);
}
if (lead.major == 1) {
- fprintf(stderr, "%s: Can't sign v1.0 RPM\n", rpm);
+ fprintf(stderr, _("%s: Can't sign v1.0 RPM\n"), rpm);
exit(1);
}
if (lead.major == 2) {
- fprintf(stderr, "%s: Can't re-sign v2.0 RPM\n", rpm);
+ fprintf(stderr, _("%s: Can't re-sign v2.0 RPM\n"), rpm);
exit(1);
}
if (rpmReadSignature(fd, &sig, lead.signature_type)) {
- fprintf(stderr, "%s: rpmReadSignature failed\n", rpm);
+ fprintf(stderr, _("%s: rpmReadSignature failed\n"), rpm);
exit(1);
}
if (add != ADD_SIGNATURE) {
ofd = open(sigtarget, O_WRONLY|O_CREAT|O_TRUNC, 0644);
while ((count = read(fd, buffer, sizeof(buffer))) > 0) {
if (count == -1) {
- perror("Couldn't read the header/archive");
+ perror(_("Couldn't read the header/archive"));
close(ofd);
unlink(sigtarget);
exit(1);
}
if (write(ofd, buffer, count) < 0) {
- perror("Couldn't write header/archive to temp file");
+ perror(_("Couldn't write header/archive to temp file"));
close(ofd);
unlink(sigtarget);
exit(1);
fd = open(sigtarget, O_RDONLY);
while ((count = read(fd, buffer, sizeof(buffer))) > 0) {
if (count == -1) {
- perror("Couldn't read sigtarget");
+ perror(_("Couldn't read sigtarget"));
close(ofd);
close(fd);
unlink(sigtarget);
exit(1);
}
if (write(ofd, buffer, count) < 0) {
- perror("Couldn't write package");
+ perror(_("Couldn't write package"));
close(ofd);
close(fd);
unlink(sigtarget);
while (*argv) {
rpm = *argv++;
if ((fd = open(rpm, O_RDONLY, 0644)) < 0) {
- fprintf(stderr, "%s: Open failed\n", rpm);
+ fprintf(stderr, _("%s: Open failed\n"), rpm);
res++;
continue;
}
if (readLead(fd, &lead)) {
- fprintf(stderr, "%s: readLead failed\n", rpm);
+ fprintf(stderr, _("%s: readLead failed\n"), rpm);
res++;
continue;
}
if (lead.major == 1) {
- fprintf(stderr, "%s: No signature available (v1.0 RPM)\n", rpm);
+ fprintf(stderr, _("%s: No signature available (v1.0 RPM)\n"), rpm);
res++;
continue;
}
if (rpmReadSignature(fd, &sig, lead.signature_type)) {
- fprintf(stderr, "%s: rpmReadSignature failed\n", rpm);
+ fprintf(stderr, _("%s: rpmReadSignature failed\n"), rpm);
res++;
continue;
}
if (! sig) {
- fprintf(stderr, "%s: No signature available\n", rpm);
+ fprintf(stderr, _("%s: No signature available\n"), rpm);
res++;
continue;
}
ofd = open(sigtarget, O_WRONLY|O_CREAT|O_TRUNC, 0644);
while ((count = read(fd, buffer, sizeof(buffer))) > 0) {
if (count == -1) {
- perror("Couldn't read the header/archive");
+ perror(_("Couldn't read the header/archive"));
close(ofd);
unlink(sigtarget);
exit(1);
}
if (write(ofd, buffer, count) < 0) {
- fprintf(stderr, "Unable to write %s", sigtarget);
+ fprintf(stderr, _("Unable to write %s"), sigtarget);
perror("");
close(ofd);
unlink(sigtarget);
fprintf(stderr, "%s", buffer);
} else {
fprintf(stderr, "%sNOT OK%s\n", buffer,
- missingKeys ? " (MISSING KEYS)" : "");
+ missingKeys ? _(" (MISSING KEYS)") : "");
}
} else {
if (rpmIsVerbose()) {
printf("%s", buffer);
} else {
printf("%sOK%s\n", buffer,
- missingKeys ? " (MISSING KEYS)" : "");
+ missingKeys ? _(" (MISSING KEYS)") : "");
}
}
}
#include "dbindex.h"
#include "falloc.h"
#include "header.h"
+#include "intl.h"
#include "misc.h"
#include "rpmdb.h"
#include "rpmlib.h"
if (!justcheck || !exists(filename)) {
db.pkgs = faOpen(filename, mode, 0644);
if (!db.pkgs) {
- rpmError(RPMERR_DBOPEN, "failed to open %s\n", filename);
+ rpmError(RPMERR_DBOPEN, _("failed to open %s\n"), filename);
return 1;
}
if (mode & O_RDWR) {
lockinfo.l_type = F_WRLCK;
if (fcntl(db.pkgs->fd, F_SETLK, (void *) &lockinfo)) {
- rpmError(RPMERR_FLOCK, "cannot get %s lock on database",
- "exclusive");
+ rpmError(RPMERR_FLOCK, _("cannot get %s lock on database"),
+ _("exclusive"));
return 1;
}
} else {
lockinfo.l_type = F_RDLCK;
if (fcntl(db.pkgs->fd, F_SETLK, (void *) &lockinfo)) {
- rpmError(RPMERR_FLOCK, "cannot get %s lock on database", "shared");
+ rpmError(RPMERR_FLOCK, _("cannot get %s lock on database"),
+ _("shared"));
return 1;
}
}
switch (rc) {
case 0:
if (dbiRemoveIndexRecord(&matches, rec) && !tolerant) {
- rpmError(RPMERR_DBCORRUPT, "package %s not listed in %s",
+ rpmError(RPMERR_DBCORRUPT, _("package %s not listed in %s"),
key, idxName);
} else {
dbiUpdateIndex(dbi, key, &matches);
break;
case 1:
if (!tolerant)
- rpmError(RPMERR_DBCORRUPT, "package %s not found in %s", key, idxName);
+ rpmError(RPMERR_DBCORRUPT, _("package %s not found in %s"),
+ key, idxName);
break;
case 2:
break; /* error message already generated from dbindex.c */
h = rpmdbGetRecord(db, offset);
if (!h) {
- rpmError(RPMERR_DBCORRUPT, "cannot read header at %d for uninstall",
+ rpmError(RPMERR_DBCORRUPT, _("cannot read header at %d for uninstall"),
offset);
return 1;
}
blockSignals();
if (!headerGetEntry(h, RPMTAG_NAME, &type, (void **) &name, &count)) {
- rpmError(RPMERR_DBCORRUPT, "package has no name");
+ rpmError(RPMERR_DBCORRUPT, _("package has no name"));
} else {
rpmMessage(RPMMESS_DEBUG, "removing name index\n");
removeIndexEntry(db->nameIndex, name, rec, tolerant, "name index");
dboffset = faAlloc(db->pkgs, headerSizeof(dbentry, HEADER_MAGIC_NO));
if (!dboffset) {
- rpmError(RPMERR_DBCORRUPT, "cannot allocate space for database");
+ rpmError(RPMERR_DBCORRUPT, _("cannot allocate space for database"));
unblockSignals();
if (providesCount) free(providesList);
if (requiredbyCount) free(requiredbyList);
oldHeader = rpmdbGetRecord(db, offset);
if (!oldHeader) {
- rpmError(RPMERR_DBCORRUPT, "cannot read header at %d for update",
+ rpmError(RPMERR_DBCORRUPT, _("cannot read header at %d for update"),
offset);
return 1;
}
#include <fcntl.h>
#include <string.h>
+#include "intl.h"
#include "md5.h"
#include "misc.h"
#include "rpmlib.h"
case RPMSIG_MD5:
case RPMSIG_MD5_PGP:
rpmError(RPMERR_BADSIGTYPE,
- "Old (internal-only) signature! How did you get that!?");
+ _("Old (internal-only) signature! How did you get that!?"));
return 1;
break;
case RPMSIG_HEADERSIG:
"+batchmode=on", "+verbose=0", "+armor=off",
name, "-sb", file, sigfile,
NULL);
- rpmError(RPMERR_EXEC, "Couldn't exec pgp");
+ rpmError(RPMERR_EXEC, _("Couldn't exec pgp"));
_exit(RPMERR_EXEC);
}
waitpid(pid, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status)) {
- rpmError(RPMERR_SIGGEN, "pgp failed");
+ rpmError(RPMERR_SIGGEN, _("pgp failed"));
return 1;
}
if (stat(sigfile, &statbuf)) {
/* PGP failed to write signature */
unlink(sigfile); /* Just in case */
- rpmError(RPMERR_SIGGEN, "pgp failed to write signature");
+ rpmError(RPMERR_SIGGEN, _("pgp failed to write signature"));
return 1;
}
unlink(sigfile);
close(fd);
free(*sig);
- rpmError(RPMERR_SIGGEN, "unable to read the signature");
+ rpmError(RPMERR_SIGGEN, _("unable to read the signature"));
return 1;
}
close(fd);
sigfile, datafile,
NULL);
printf("exec failed!\n");
- rpmError(RPMERR_EXEC, "Could not run pgp. Use --nopgp to skip PGP checks.");
+ rpmError(RPMERR_EXEC,
+ _("Could not run pgp. Use --nopgp to skip PGP checks."));
_exit(RPMERR_EXEC);
}
if (! rpmGetVar(RPMVAR_PGP_NAME)) {
rpmError(RPMERR_SIGGEN,
- "You must set \"pgp_name:\" in your rpmrc file");
+ _("You must set \"pgp_name:\" in your rpmrc file"));
return NULL;
}
"+batchmode=on", "+verbose=0",
name, "-sf",
NULL);
- rpmError(RPMERR_EXEC, "Couldn't exec pgp");
+ rpmError(RPMERR_EXEC, _("Couldn't exec pgp"));
_exit(RPMERR_EXEC);
}
#include <unistd.h>
#include "install.h"
+#include "intl.h"
#include "messages.h"
#include "md5.h"
#include "misc.h"
secOffset = sharedList[i].secRecOffset;
sech = rpmdbGetRecord(db, secOffset);
if (!sech) {
- rpmError(RPMERR_DBCORRUPT, "cannot read header at %d for "
- "uninstall", offset);
+ rpmError(RPMERR_DBCORRUPT,
+ _("cannot read header at %d for uninstall"), offset);
rc = 1;
break;
}
headerGetEntry(sech, RPMTAG_RELEASE, &type, (void **) &release,
&secFileCount);
- rpmMessage(RPMMESS_DEBUG, "package %s-%s-%s contain shared files\n",
- name, version, release);
+ rpmMessage(RPMMESS_DEBUG,
+ _("package %s-%s-%s contain shared files\n"),
+ name, version, release);
if (!headerGetEntry(sech, RPMTAG_FILENAMES, &type,
(void **) &secFileList, &secFileCount)) {
fd = open(fn, O_CREAT | O_RDWR);
if (!isdebug) unlink(fn);
if (fd < 0) {
- rpmError(RPMERR_SCRIPT, "error creating file for (un)install script");
+ rpmError(RPMERR_SCRIPT,
+ _("error creating file for (un)install script"));
return 1;
}
write(fd, SCRIPT_PATH, strlen(SCRIPT_PATH));
waitpid(child, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status)) {
- rpmError(RPMERR_SCRIPT, "execution of script failed");
+ rpmError(RPMERR_SCRIPT, _("execution of script failed"));
return 1;
}
}
rc = mdfile(file, currentMd5);
if (mdfile(file, currentMd5))
- rpmMessage(RPMMESS_DEBUG, " failed - assuming file removed\n");
+ rpmMessage(RPMMESS_DEBUG,
+ " failed - assuming file removed\n");
else {
if (strcmp(currentMd5, md5)) {
rpmMessage(RPMMESS_DEBUG, " file changed - will save\n");
action = BACKUP;
} else {
- rpmMessage(RPMMESS_DEBUG, " file unchanged - will remove\n");
+ rpmMessage(RPMMESS_DEBUG,
+ " file unchanged - will remove\n");
}
}
}
strcpy(newfile, file);
strcat(newfile, ".rpmsave");
if (rename(file, newfile)) {
- rpmError(RPMERR_RENAME, "rename of %s to %s failed: %s",
+ rpmError(RPMERR_RENAME, _("rename of %s to %s failed: %s"),
file, newfile, strerror(errno));
rc = 1;
}
if (!test) {
if (rmdir(file)) {
if (errno == ENOTEMPTY)
- rpmError(RPMERR_RMDIR, "cannot remove %s - directory "
- "not empty", file);
+ rpmError(RPMERR_RMDIR,
+ _("cannot remove %s - directory not empty"),
+ file);
else
- rpmError(RPMERR_RMDIR, "rmdir of %s failed: %s",
+ rpmError(RPMERR_RMDIR, _("rmdir of %s failed: %s"),
file, strerror(errno));
rc = 1;
}
} else {
if (!test) {
if (unlink(file)) {
- rpmError(RPMERR_UNLINK, "removal of %s failed: %s",
+ rpmError(RPMERR_UNLINK, _("removal of %s failed: %s"),
file, strerror(errno));
rc = 1;
}