~ubuntu-branches/ubuntu/raring/reprepro/raring

gpgme_ctx_t context = NULL;

 

retvalue gpgerror(gpg_error_t err) {

                fprintf(stderr, "gpgme gave error %s:%d:  %s\n",

                                gpg_strsource(err), gpg_err_code(err),

                                gpg_strerror(err));

                        return RET_ERROR_OOM;

                else

                        return RET_ERROR_GPGME;

        msg = mprintf("%s needs a passphrase\nPlease enter passphrase%s:",

                        (uid_hint!=NULL)?uid_hint:"key",

                        (prev_was_bad!=0)?" again":"");

                return gpg_err_make(GPG_ERR_SOURCE_USER_1, GPG_ERR_ENOMEM);

        p = getpass(msg);

        write(fd, p, strlen(p));

#ifdef HAVE_LIBGPGME

        gpg_error_t err;

 

                return RET_NOTHING;

        gpgme_check_version(NULL);

        err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);

                return gpgerror(err);

        err = gpgme_new(&context);

#endif /* HAVE_LIBGPGME */

        return RET_OK;

}

 

void signatures_done(void) {

#ifdef HAVE_LIBGPGME

                gpgme_release(context);

                context = NULL;

        }

        int i;

 

        signresult = gpgme_op_sign_result(context);

                return RET_OK;

        /* in an ideal world, this point is never reached.

         * Sadly it is and people are obviously confused by it,

         * so do some work to give helpful messages. */

                assert (options->count > 0);

                uidoptions = mprintf(" -u '%s'", options->values[0]);

                     uidoptions != NULL && i < options->count ;

                        char *u = mprintf("%s -u '%s'", uidoptions,

                                        options->values[0]);

                        free(uidoptions);

                        uidoptions = u;

                }

                        return RET_ERROR_OOM;

        } else

                uidoptions = NULL;

 

                fputs(

"Error: gpgme returned NULL unexpectedly for gpgme_op_sign_result\n", stderr);

        else

        fputs(

"This most likely means gpg is confused or produces some error libgpgme is\n"

"not able to understand. Try running\n", stderr);

                fprintf(stderr,

"gpg %s --output 'some-other-file' %s 'some-file'\n",

                        (uidoptions==NULL)?"":uidoptions,

        int fd, e, ret;

 

        signature_data = gpgme_data_release_and_get_mem(dh_gpg, &signature_len);

                return RET_ERROR_OOM;

        fd = open(signaturename, O_WRONLY|O_CREAT|O_EXCL|O_NOCTTY|O_NOFOLLOW, 0666);

                free(signature_data);

                return RET_ERRNO(errno);

        }

        p = signature_data;

                written = write(fd, p, signature_len);

                        e = errno;

                        fprintf(stderr, "Error %d writing to %s: %s\n",

                                        e, signaturename,

        free(signature_data);

#endif

        ret = close(fd);

                e = errno;

                fprintf(stderr, "Error %d writing to %s: %s\n",

                                e, signaturename,

                                strerror(e));

                return RET_ERRNO(e);

        }

                printf("Successfully created '%s'\n", signaturename);

        }

        return RET_OK;

        retvalue r;

 

        err = gpgme_data_new(&dh_gpg);

                return gpgerror(err);

        err = gpgme_op_sign(context, dh, dh_gpg,

                        clearsign?GPGME_SIG_MODE_CLEAR:GPGME_SIG_MODE_DETACH);

                return gpgerror(err);

        r = check_signature_created(clearsign, willcleanup,

                        options, filename, signaturename);

                gpgme_data_release(dh_gpg);

                return r;

        }

        gpgme_data_t dh;

#endif /* HAVE_LIBGPGME */

 

 

        r = signature_init(false);

                return r;

 

        /* make sure it does not already exists */

 

        ret = unlink(signaturename);

                                signaturename, strerror(e));

                return RET_ERROR;

        }

        ret = unlink(clearsignfilename);

                                clearsignfilename, strerror(e));

                return RET_ERROR;

        }

 

                // TODO: allow external programs, too

                return RET_ERROR;

        }

#ifdef HAVE_LIBGPGME

        gpgme_signers_clear(context);

                        (strcasecmp(options->values[0], "yes") == 0 ||

                /* use default options */

                options = NULL;

                const char *option = options->values[i];

                gpgme_key_t key;

 

                err = gpgme_op_keylist_start(context, option, 1);

                        return gpgerror(err);

                err = gpgme_op_keylist_next(context, &key);

                        return RET_ERROR;

                }

                err = gpgme_signers_add(context, key);

                gpgme_key_unref(key);

                        gpgme_op_keylist_end(context);

                        return gpgerror(err);

                }

        }

 

        err = gpgme_data_new_from_mem(&dh, data, datalen, 0);

                return gpgerror(err);

        }

 

        r = create_signature(false, dh, options,

                        filename, signaturename, willcleanup);

                gpgme_data_release(dh);

                return r;

        }

        i = gpgme_data_seek(dh, 0, SEEK_SET);

                e = errno;

                fprintf(stderr,

"Error %d rewinding gpgme's data buffer to start: %s\n",

        r = create_signature(true, dh, options,

                        filename, clearsignfilename, willcleanup);

        gpgme_data_release(dh);

                return r;

        return RET_OK;

#else /* HAVE_LIBGPGME */

        struct signature *sig;

 

        result = gpgme_op_verify_result(context);

                return RET_ERROR_GPGME;

        }

                count = 0;

                        count++;

                }

                signatures = calloc(1, sizeof(struct signatures) +

                                count * sizeof(struct signature));

                        return RET_ERROR_OOM;

                signatures->count = count;

                signatures->validcount = 0;

                signatures = NULL;

                sig = NULL;

        }

                enum signature_state state = sist_error;

 

                        sig->keyid = strdup(s->fpr);

                                signatures_free(signatures);

                                return RET_ERROR_OOM;

                        }

                }

                        case GPG_ERR_NO_ERROR:

                                had_valid = true;

                                state = sist_valid;

                                        signatures->validcount++;

                                break;

                        case GPG_ERR_KEY_EXPIRED:

                                had_valid = true;

                                        fprintf(stderr,

"Ignoring signature with '%s' on '%s', as the key has expired.\n",

                                                s->fpr, filename);

                                state = sist_mostly;

                                        sig->expired_key = true;

                                break;

                        case GPG_ERR_CERT_REVOKED:

                                had_valid = true;

                                        fprintf(stderr,

"Ignoring signature with '%s' on '%s', as the key is revoked.\n",

                                                s->fpr, filename);

                                state = sist_mostly;

                                        sig->revoced_key = true;

                                break;

                        case GPG_ERR_SIG_EXPIRED:

                                had_valid = true;

                                        time_t timestamp = s->timestamp,

                                              exp_timestamp = s->exp_timestamp;

                                        fprintf(stderr,

                                                ctime(&exp_timestamp));

                                }

                                state = sist_mostly;

                                        sig->expired_signature = true;

                                break;

                        case GPG_ERR_BAD_SIGNATURE:

                                had_broken = true;

                                        fprintf(stderr,

"WARNING: '%s' has a invalid signature with '%s'\n", filename, s->fpr);

                                }

                                state = sist_bad;

                                break;

                        case GPG_ERR_NO_PUBKEY:

                                        fprintf(stderr,

"Could not check validity of signature with '%s' in '%s' as public key missing!\n",

                                                s->fpr, filename);

                        default:

                                break;

                }

                        fprintf(stderr,

"Error checking signature (gpgme returned unexpected value %d)!\n"

"Please file a bug report, so reprepro can handle this in the future.\n",

                        signatures_free(signatures);

                        return RET_ERROR_GPGME;

                }

                        sig->state = state;

                        sig++;

                }

        }

                *broken = true;

                *signatures_p = signatures;

        return RET_OK;

}

           valid if the primary key is expired */

        int i;

 

                gpg_error_t err;

                gpgme_key_t gpgme_key = NULL;

                gpgme_subkey_t subkey;

                struct signature *sig = &signatures->signatures[i];

 

                        sig->primary_keyid = strdup(sig->keyid);

                                return RET_ERROR_OOM;

                        continue;

                }

 

                err = gpgme_get_key(context, sig->keyid, &gpgme_key, 0);

                                        sig->keyid, gpg_strerror(err));

                                return RET_ERROR_OOM;

                        else

                                return RET_ERROR_GPGME;

                }

                /* the first "sub"key is the primary key */

                subkey = gpgme_key->subkeys;

                        sig->revoced_key = true;

                                sig->state = sist_mostly;

                                signatures->validcount--;

                        }

                }

                        sig->expired_key = true;

                                sig->state = sist_mostly;

                                signatures->validcount--;

                        }

                }

                sig->primary_keyid = strdup(subkey->keyid);

                gpgme_key_unref(gpgme_key);

                        return RET_ERROR_OOM;

        }

        return RET_OK;

#endif /* HAVE_LIBGPGME */

 

static inline void extractchunk(const char *buffer, const char **begin, const char **end, const char **next) {

 

        startofchanges = buffer;

                startofchanges++;

 

        endofchanges = startofchanges;

        afterchanges = NULL;

                        endofchanges++;

                        afterchanges = endofchanges;

                                afterchanges++;

                                break;

                        endofchanges = afterchanges;

                        afterchanges = NULL;

                        endofchanges++;

        }

 

                afterchanges = endofchanges;

        else

                        afterchanges++;

        *begin = startofchanges;

        *end = endofchanges;

void signatures_free(struct signatures *signatures) {

        int i;

 

                return;

 

                free(signatures->signatures[i].keyid);

                free(signatures->signatures[i].primary_keyid);

        }

 

#ifdef HAVE_LIBGPGME

static retvalue extract_signed_data(const char *buffer, size_t bufferlen, const char *filenametoshow, char **chunkread, /*@null@*/ /*@out@*/struct signatures **signatures_p, bool *brokensignature, bool *failed) {

        char *chunk;

        gpg_error_t err;

        size_t plain_len;

        char *plain_data;

        retvalue r;

        bool foundbroken = false;

 

        r = signature_init(false);

                return r;

 

        err = gpgme_data_new_from_mem(&dh_gpg, buffer, bufferlen, 0);

                return gpgerror(err);

 

        err = gpgme_data_new(&dh);

                gpgme_data_release(dh_gpg);

                return gpgerror(err);

        }

        err = gpgme_op_verify(context, dh_gpg, NULL, dh);

                gpgme_data_release(dh);

                gpgme_data_release(dh_gpg);

                return RET_NOTHING;

        } else {

                        gpgme_data_release(dh_gpg);

                        gpgme_data_release(dh);

                        return gpgerror(err);

                }

                        r = checksigs(filenametoshow,

                                (signatures_p!=NULL)?&signatures:NULL,

                                (brokensignature!=NULL)?&foundbroken:NULL);

                                gpgme_data_release(dh_gpg);

                                gpgme_data_release(dh);

                                return r;

                        }

                }

                gpgme_data_release(dh_gpg);

                        fprintf(stderr,

"(not yet fatal) ERROR: libgpgme failed to extract the plain data out of\n"

"'%s'.\n"

                        signatures_free(signatures);

                        return RET_NOTHING;

                }

                        r = check_primary_keys(signatures);

                                signatures_free(signatures);

                                return r;

                        }

                }

        }

 

                r = RET_ERROR_OOM;

        else {

                // TODO: check if the new extractchunk can be used...

 

                startofchanges = plain_data;

                        startofchanges++;

                }

                        fprintf(stderr,

"Could only find spaces within '%s'!\n",

                                        filenametoshow);

                } else

                        r = RET_OK;

        }

                endofchanges = startofchanges;

                                *endofchanges != '\0' &&

                        endofchanges++;

                }

                afterchanges = endofchanges;

                        afterchanges++;

                }

                                fprintf(stderr,

"Unexpected \\0 character within '%s'!\n",

                                        filenametoshow);

                        r = RET_ERROR;

                }

        }

                        r = RET_ERROR_OOM;

                else

                        *chunkread = chunk;

#else

        free(plain_data);

#endif

                        *signatures_p = signatures;

                        *brokensignature = foundbroken;

        } else {

                signatures_free(signatures);

/* Read a single chunk from a file, that may be signed. */

retvalue signature_readsignedchunk(const char *filename, const char *filenametoshow, char **chunkread, /*@null@*/ /*@out@*/struct signatures **signatures_p, bool *brokensignature) {

        char *chunk, *h, *afterchunk;

        size_t chunklen, len;

        retvalue r;

        bool failed = false;

 

        r = readtextfile(filename, filenametoshow, &chunk, &chunklen);

                return r;

 

                fprintf(stderr, "Unexpected empty file '%s'!\n",

                                        filenametoshow);

                free(chunk);

        }

 

        extractchunk(chunk, &startofchanges, &endofchanges, &afterchanges);

                fprintf(stderr, "Could only find spaces within '%s'!\n",

                                        filenametoshow);

                free(chunk);

        }

 

        /* fast-track unsigned chunks: */

                len = chunk_extract(chunk, chunk, &afterchunk);

                h = realloc(chunk, len + 1);

                        chunk = h;

                *chunkread = chunk;

                        *signatures_p = NULL;

                        *brokensignature = false;

                return RET_OK;

        }

 

                free(chunk);

                return RET_ERROR;

        }

#ifdef HAVE_LIBGPGME

        r = extract_signed_data(chunk, chunklen, filenametoshow, chunkread,

                        signatures_p, brokensignature, &failed);

                free(chunk);

                return r;

        }

        /* We have no libgpgme, it failed, or could not find signature data,

         * trying to extract it manually, ignoring signatures: */

 

                fprintf(stderr,

"First non-space character is a '-' but there is no empty line in\n"

"'%s'.\n"

                free(chunk);

                return RET_ERROR;

        }

                fprintf(stderr,

"Strange content of '%s': First non-space character is '-',\n"

"but it does not begin with '-----BEGIN'.\n", filenametoshow);

 

        len = chunk_extract(chunk, afterchanges, &afterchunk);

 

                                filenametoshow);

                free(chunk);

                return RET_ERROR;

        }

 

                const char *endmarker;

 

                endmarker = strstr(chunk, "\n-----");

                        endmarker++;

                        len = endmarker-chunk;

                        chunk[len] = '\0';

                } else {

                        free(chunk);

                        return RET_ERROR;

                }

"Cannot determine what is data and what is not!\n",

                                filenametoshow);

                free(chunk);

                return RET_ERROR;

        }

 

        h = realloc(chunk, len + 1);

                chunk = h;

                /* pointer to structure with count 0 to make clear

                 * it is not unsigned */

                *signatures_p = calloc(1, sizeof(struct signatures));

                        free(chunk);

                        return RET_ERROR_OOM;

                }

        }

        *chunkread = chunk;

                *brokensignature = false;

        return RET_OK;

}

retvalue signature_startsignedfile(const char *directory, const char *basefilename, const char *inlinefilename, struct signedfile **out) {

        struct signedfile *n;

 

                return RET_ERROR_OOM;

        n->plainfilename = calc_dirconcat(directory, basefilename);

                free(n);

                return RET_ERROR_OOM;

        }

        n->inlinefilename = calc_dirconcat(directory, inlinefilename);

                free(n->plainfilename);

                free(n);

                return RET_ERROR_OOM;

        n->bufferlen = 0;

        n->buffersize = DATABUFFERUNITS;

        n->buffer = malloc(n->buffersize);

                free(n->plainfilename);

                free(n->inlinefilename);

                free(n);

}

 

void signedfile_free(struct signedfile *f, bool cleanup) {

                return;

                        (void)unlink(f->newplainfilename);

                free(f->newplainfilename);

        }

        free(f->plainfilename);

                        (void)unlink(f->newsignfilename);

                free(f->newsignfilename);

        }

        free(f->signfilename);

                        (void)unlink(f->newinlinefilename);

                free(f->newinlinefilename);

        }

void signedfile_write(struct signedfile *f, const void *data, size_t len) {

 

        /* no need to try anything if there already was an error */

                return;

 

                size_t blocks = (len + f->bufferlen)/DATABUFFERUNITS;

                size_t newsize = (blocks + 1) * DATABUFFERUNITS;

                char *newbuffer;

 

                /* realloc is wasteful, but should not happen too often */

                newbuffer = realloc(f->buffer, newsize);

                        free(f->buffer);

                        f->buffer = NULL;

                        f->result = RET_ERROR_OOM;

                }

                f->buffer = newbuffer;

                f->buffersize = newsize;

        }

        memcpy(f->buffer + f->bufferlen, data, len);

        f->bufferlen += len;

}

 

retvalue signedfile_prepare(struct signedfile *f, const struct strlist *options, bool willcleanup) {

        size_t len, ofs;

        int fd, ret;

 

                return f->result;

 

        /* write content to file */

 

        f->newplainfilename = calc_addsuffix(f->plainfilename, "new");

                return RET_ERROR_OOM;

 

        (void)dirs_make_parent(f->newplainfilename);

        (void)unlink(f->newplainfilename);

 

        fd = open(f->newplainfilename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0666);

                int e = errno;

                fprintf(stderr, "Error creating file '%s': %s\n",

                                f->newplainfilename,

        }

        ofs = 0;

        len = f->bufferlen;

                ssize_t written;

 

                written = write(fd, f->buffer + ofs, len);

                        int e = errno;

                        fprintf(stderr, "Error %d writing to file '%s': %s\n",

                                        e, f->newplainfilename,

                        f->newplainfilename = NULL;

                        return RET_ERRNO(e);

                }

                ofs += written;

                len -= written;

        }

        ret = close(fd);

                int e = errno;

                fprintf(stderr, "Error %d writing to file '%s': %s\n",

                                e, f->newplainfilename,

                return RET_ERRNO(e);

        }

        /* now do the actual signing */

                retvalue r;

 

                f->signfilename = calc_addsuffix(f->plainfilename, "gpg");

                        return RET_ERROR_OOM;

                f->newsignfilename = calc_addsuffix(f->signfilename, "new");

                        return RET_ERROR_OOM;

                f->newinlinefilename = calc_addsuffix(f->inlinefilename, "new");

                        return RET_ERROR_OOM;

 

                r = signature_sign(options,

                                f->newsignfilename,

                                f->newinlinefilename,

                                willcleanup);

                        return r;

        }

        return RET_OK;

        retvalue result = RET_OK, r;

        int e;

 

                e = rename(f->newsignfilename, f->signfilename);

                        e = errno;

                        fprintf(stderr, "Error %d moving %s to %s: %s!\n", e,

                                        f->newsignfilename,

                        result = RET_ERRNO(e);

                        /* after something was done, do not stop

                         * but try to do as much as possible */

                                return result;

                } else {

                        /* does not need deletion any more */

                        *toolate = true;

                }

        }

                e = rename(f->newinlinefilename, f->inlinefilename);

                        e = errno;

                        fprintf(stderr, "Error %d moving %s to %s: %s!\n", e,

                                        f->newinlinefilename,

                        result = RET_ERRNO(e);

                        /* after something was done, do not stop

                         * but try to do as much as possible */

                                return result;

                } else {

                        /* does not need deletion any more */

                }

        }

        e = rename(f->newplainfilename, f->plainfilename);

                e = errno;

                fprintf(stderr, "Error %d moving %s to %s: %s!\n", e,

                                f->newplainfilename,