PeerStreamer

/*

  Copyright 2003 John Knottenbelt

  This program is free software; you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation; either version 2 of the License, or

  (at your option) any later version.

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with this program; if not, write to the Free Software

  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.

*/

#include "config.h"

#include "outputbuffer.h"

#include "dvbd.h"

#include <unistd.h>

#include <iostream>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/un.h>

OutputBuffer::OutputBuffer(int fd, int initSize, int maxSize)

  : CircularBuffer(initSize, maxSize), fd(fd)

{

}

OutputBuffer::~OutputBuffer()

{

}

void OutputBuffer::addSelectFDs(Select &s) const

{

  if (getUsed() > 0)

    s.addWriteFD(fd);

}

bool OutputBuffer::isReady(const Select &s) const

{

  return s.readyToWrite(fd);

}

bool OutputBuffer::process()

{

  if (getUsed() == 0)

    return true;

  // We are using a circular buffer. 

  // Write only the first half (if there is a second

  // half, we will get it next round).

  char *buffer1, *buffer2;

  int length1, length2;

  getSections(buffer1, length1, buffer2, length2);

  if (length1 == 0) {

    buffer1 = buffer2;

    length1 = length2;

  }

  int bytesWritten = ::write(fd, buffer1, length1);

  if (bytesWritten <= 0)

    return errno == EAGAIN;

  discard(bytesWritten);

  return true;

}

bool OutputBuffer::flush()

{

  // Flush the entire output buffer (blocking)

  Select s;

  while (getUsed() > 0) {

    addSelectFDs(s);

    s.wait();

    if (!isReady(s))

      return false;

    if (!process())

      return false;

    s.clearFDs();

  }

  return true;

}

bool OutputBuffer::writeCredentials()

{

  struct msghdr msg;

  char buffer[CMSG_SPACE(sizeof(struct ucred))];

  msg.msg_name = NULL;

  msg.msg_namelen = 0;

  msg.msg_iov = 0;

  msg.msg_iovlen = 0;

  msg.msg_control = buffer;

  msg.msg_controllen = sizeof(buffer);

  msg.msg_flags = 0;

  struct ucred ucred;

  ucred.pid = getpid();

  ucred.uid = getuid();

  ucred.gid = getgid();

  struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);

  cmsg->cmsg_level = SOL_SOCKET;

  cmsg->cmsg_type = SCM_CREDENTIALS;

  cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));

  memcpy(CMSG_DATA(cmsg), &ucred, sizeof(struct ucred));

  return sendmsg(fd, &msg, 0) >= 0;

}