code stringlengths 4 1.01M | language stringclasses 2 values |
|---|---|
package tim.prune.threedee;
import java.awt.event.InputEvent;
/*
* Copyright (c) 2007 Sun Microsystems, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistribution of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any
* kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
* EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL
* NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF
* USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR
* ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL,
* CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND
* REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR
* INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed, licensed or
* intended for use in the design, construction, operation or
* maintenance of any nuclear facility.
*
* Copyright (c) 2021 ActivityWorkshop simplifications and renamings,
* and restriction to upright orientations.
*/
import java.awt.event.MouseEvent;
import java.awt.AWTEvent;
import javax.media.j3d.Transform3D;
import javax.media.j3d.Canvas3D;
import javax.vecmath.Vector3d;
import javax.vecmath.Point3d;
import javax.vecmath.Matrix3d;
import com.sun.j3d.utils.behaviors.vp.ViewPlatformAWTBehavior;
import com.sun.j3d.utils.universe.ViewingPlatform;
/**
* Moves the View around a point of interest when the mouse is dragged with
* a mouse button pressed. Includes rotation, zoom, and translation
* actions. Zooming can also be obtained by using mouse wheel.
* <p>
* The rotate action rotates the ViewPlatform around the point of interest
* when the mouse is moved with the main mouse button pressed. The
* rotation is in the direction of the mouse movement, with a default
* rotation of 0.01 radians for each pixel of mouse movement.
* <p>
* The zoom action moves the ViewPlatform closer to or further from the
* point of interest when the mouse is moved with the middle mouse button
* pressed (or Alt-main mouse button on systems without a middle mouse button).
* The default zoom action is to translate the ViewPlatform 0.01 units for each
* pixel of mouse movement. Moving the mouse up moves the ViewPlatform closer,
* moving the mouse down moves the ViewPlatform further away.
* <p>
* The translate action translates the ViewPlatform when the mouse is moved
* with the right mouse button pressed. The translation is in the direction
* of the mouse movement, with a default translation of 0.01 units for each
* pixel of mouse movement.
* <p>
* The actions can be reversed using the <code>REVERSE_</code><i>ACTION</i>
* constructor flags. The default action moves the ViewPlatform around the
* objects in the scene. The <code>REVERSE_</code><i>ACTION</i> flags can
* make the objects in the scene appear to be moving in the direction
* of the mouse movement.
*/
public class UprightOrbiter extends ViewPlatformAWTBehavior
{
private Transform3D _longitudeTransform = new Transform3D();
private Transform3D _latitudeTransform = new Transform3D();
private Transform3D _rotateTransform = new Transform3D();
// needed for integrateTransforms but don't want to new every time
private Transform3D _temp1 = new Transform3D();
private Transform3D _temp2 = new Transform3D();
private Transform3D _translation = new Transform3D();
private Vector3d _transVector = new Vector3d();
private Vector3d _distanceVector = new Vector3d();
private Vector3d _centerVector = new Vector3d();
private Vector3d _invertCenterVector = new Vector3d();
private double _deltaYaw = 0.0, _deltaPitch = 0.0;
private double _startDistanceFromCenter = 20.0;
private double _distanceFromCenter = 20.0;
private Point3d _rotationCenter = new Point3d();
private Matrix3d _rotMatrix = new Matrix3d();
private int _mouseX = 0, _mouseY = 0;
private double _xtrans = 0.0, _ytrans = 0.0, _ztrans = 0.0;
private static final double MIN_RADIUS = 0.0;
// the factor to be applied to wheel zooming so that it does not
// look much different with mouse movement zooming.
private static final float wheelZoomFactor = 50.0f;
private static final double NOMINAL_ZOOM_FACTOR = .01;
private static final double NOMINAL_ROT_FACTOR = .008;
private static final double NOMINAL_TRANS_FACTOR = .003;
private double _pitchAngle = 0.0;
/**
* Creates a new OrbitBehaviour
* @param inCanvas The Canvas3D to add the behaviour to
* @param inInitialPitch pitch angle in degrees
*/
public UprightOrbiter(Canvas3D inCanvas, double inInitialPitch)
{
super(inCanvas, MOUSE_LISTENER | MOUSE_MOTION_LISTENER | MOUSE_WHEEL_LISTENER );
_pitchAngle = Math.toRadians(inInitialPitch);
}
protected synchronized void processAWTEvents( final AWTEvent[] events )
{
motion = false;
for (AWTEvent event : events) {
if (event instanceof MouseEvent) {
processMouseEvent((MouseEvent) event);
}
}
}
protected void processMouseEvent( final MouseEvent evt )
{
if (evt.getID() == MouseEvent.MOUSE_PRESSED) {
_mouseX = evt.getX();
_mouseY = evt.getY();
motion = true;
}
else if (evt.getID() == MouseEvent.MOUSE_DRAGGED)
{
int xchange = evt.getX() - _mouseX;
int ychange = evt.getY() - _mouseY;
// rotate
if (isRotateEvent(evt))
{
_deltaYaw -= xchange * NOMINAL_ROT_FACTOR;
_deltaPitch -= ychange * NOMINAL_ROT_FACTOR;
}
// translate
else if (isTranslateEvent(evt))
{
_xtrans -= xchange * NOMINAL_TRANS_FACTOR;
_ytrans += ychange * NOMINAL_TRANS_FACTOR;
}
// zoom
else if (isZoomEvent(evt)) {
doZoomOperations( ychange );
}
_mouseX = evt.getX();
_mouseY = evt.getY();
motion = true;
}
else if (evt.getID() == MouseEvent.MOUSE_WHEEL )
{
if (isZoomEvent(evt))
{
// if zooming is done through mouse wheel, the number of wheel increments
// is multiplied by the wheelZoomFactor, to make zoom speed look natural
if ( evt instanceof java.awt.event.MouseWheelEvent)
{
int zoom = ((int)(((java.awt.event.MouseWheelEvent)evt).getWheelRotation()
* wheelZoomFactor));
doZoomOperations( zoom );
motion = true;
}
}
}
}
/*
* zoom but stop at MIN_RADIUS
*/
private void doZoomOperations( int ychange )
{
if ((_distanceFromCenter - ychange * NOMINAL_ZOOM_FACTOR) > MIN_RADIUS) {
_distanceFromCenter -= ychange * NOMINAL_ZOOM_FACTOR;
}
else {
_distanceFromCenter = MIN_RADIUS;
}
}
/**
* Sets the ViewingPlatform for this behaviour. This method is
* called by the ViewingPlatform.
* If a sub-calls overrides this method, it must call
* super.setViewingPlatform(vp).
* NOTE: Applications should <i>not</i> call this method.
*/
@Override
public void setViewingPlatform(ViewingPlatform vp)
{
super.setViewingPlatform( vp );
if (vp != null) {
resetView();
integrateTransforms();
}
}
/**
* Reset the orientation and distance of this behaviour to the current
* values in the ViewPlatform Transform Group
*/
private void resetView()
{
Vector3d centerToView = new Vector3d();
targetTG.getTransform( targetTransform );
targetTransform.get( _rotMatrix, _transVector );
centerToView.sub( _transVector, _rotationCenter );
_distanceFromCenter = centerToView.length();
_startDistanceFromCenter = _distanceFromCenter;
targetTransform.get( _rotMatrix );
_rotateTransform.set( _rotMatrix );
// compute the initial x/y/z offset
_temp1.set(centerToView);
_rotateTransform.invert();
_rotateTransform.mul(_temp1);
_rotateTransform.get(centerToView);
_xtrans = centerToView.x;
_ytrans = centerToView.y;
_ztrans = centerToView.z;
// reset rotMatrix
_rotateTransform.set( _rotMatrix );
}
protected synchronized void integrateTransforms()
{
// Check if the transform has been changed by another behaviour
Transform3D currentXfm = new Transform3D();
targetTG.getTransform(currentXfm);
if (! targetTransform.equals(currentXfm))
resetView();
// Three-step rotation process, firstly undo the pitch and apply the delta yaw
_latitudeTransform.rotX(_pitchAngle);
_rotateTransform.mul(_rotateTransform, _latitudeTransform);
_longitudeTransform.rotY( _deltaYaw );
_rotateTransform.mul(_rotateTransform, _longitudeTransform);
// Now update pitch angle according to delta and apply
_pitchAngle = Math.min(Math.max(0.0, _pitchAngle - _deltaPitch), Math.PI/2.0);
_latitudeTransform.rotX(-_pitchAngle);
_rotateTransform.mul(_rotateTransform, _latitudeTransform);
_distanceVector.z = _distanceFromCenter - _startDistanceFromCenter;
_temp1.set(_distanceVector);
_temp1.mul(_rotateTransform, _temp1);
// want to look at rotationCenter
_transVector.x = _rotationCenter.x + _xtrans;
_transVector.y = _rotationCenter.y + _ytrans;
_transVector.z = _rotationCenter.z + _ztrans;
_translation.set(_transVector);
targetTransform.mul(_temp1, _translation);
// handle rotationCenter
_temp1.set(_centerVector);
_temp1.mul(targetTransform);
_invertCenterVector.x = -_centerVector.x;
_invertCenterVector.y = -_centerVector.y;
_invertCenterVector.z = -_centerVector.z;
_temp2.set(_invertCenterVector);
targetTransform.mul(_temp1, _temp2);
Vector3d finalTranslation = new Vector3d();
targetTransform.get(finalTranslation);
targetTG.setTransform(targetTransform);
// reset yaw and pitch deltas
_deltaYaw = 0.0;
_deltaPitch = 0.0;
}
private boolean isRotateEvent(MouseEvent evt)
{
final boolean isRightDrag = (evt.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) > 0;
return !evt.isAltDown() && !isRightDrag;
}
private boolean isZoomEvent(MouseEvent evt)
{
if (evt instanceof java.awt.event.MouseWheelEvent) {
return true;
}
return evt.isAltDown() && !evt.isMetaDown();
}
private boolean isTranslateEvent(MouseEvent evt)
{
final boolean isRightDrag = (evt.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) > 0;
return !evt.isAltDown() && isRightDrag;
}
}
| Java |
/*
mkvtoolnix - A set of programs for manipulating Matroska files
Distributed under the GPL
see the file COPYING for details
or visit http://www.gnu.org/copyleft/gpl.html
Cross platform compatibility definitions
Written by Moritz Bunkus <moritz@bunkus.org>.
*/
#ifndef MTX_COMMON_OS_H
#define MTX_COMMON_OS_H
#undef __STRICT_ANSI__
#include "config.h"
// For PRId64 and PRIu64:
#define __STDC_FORMAT_MACROS
#if defined(HAVE_COREC_H)
#include "corec.h"
#if defined(TARGET_WIN)
# define SYS_WINDOWS
#elif defined(TARGET_OSX)
# define SYS_APPLE
#elif defined(TARGET_LINUX)
# define SYS_UNIX
# if defined(__sun) && defined(__SVR4)
# define SYS_SOLARIS
# else
# define SYS_LINUX
# endif
#endif
#else // HAVE_COREC_H
#if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
# define SYS_WINDOWS
#elif defined(__APPLE__)
# define SYS_APPLE
#else
# define COMP_GCC
# define SYS_UNIX
# if defined(__bsdi__) || defined(__FreeBSD__)
# define SYS_BSD
# elif defined(__sun) && defined(__SUNPRO_CC)
# undef COMP_GCC
# define COMP_SUNPRO
# define SYS_SOLARIS
# elif defined(__sun) && defined(__SVR4)
# define SYS_SOLARIS
# else
# define SYS_LINUX
# endif
#endif
#endif // HAVE_COREC_H
#if defined(SYS_WINDOWS)
# if defined __MINGW32__
# define COMP_MINGW
# elif defined __CYGWIN__
# define COMP_CYGWIN
# else
# define COMP_MSC
# define NOMINMAX
# endif
#endif
#if (defined(SYS_WINDOWS) && defined(_WIN64)) || (!defined(SYS_WINDOWS) && (defined(__x86_64__) || defined(__ppc64__)))
# define ARCH_64BIT
#else
# define ARCH_32BIT
#endif
#if defined(COMP_MSC)
#if !defined(HAVE_COREC_H)
# define strncasecmp _strnicmp
# define strcasecmp _stricmp
typedef __int64 int64_t;
typedef __int32 int32_t;
typedef __int16 int16_t;
typedef __int8 int8_t;
typedef unsigned __int64 uint64_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int8 uint8_t;
#endif // HAVE_COREC_H
# define nice(a)
#include <io.h>
typedef _fsize_t ssize_t;
#define PACKED_STRUCTURE
#else // COMP_MSC
#define PACKED_STRUCTURE __attribute__((__packed__))
#endif // COMP_MSC
#if defined(COMP_MINGW) || defined(COMP_MSC)
# if defined(COMP_MINGW)
// mingw is a special case. It does have inttypes.h declaring
// PRId64 to be I64d, but it warns about "int type format, different
// type argument" if %I64d is used with a int64_t. The mx* functions
// convert %lld to %I64d on mingw/msvc anyway.
# undef PRId64
# define PRId64 "lld"
# undef PRIu64
# define PRIu64 "llu"
# undef PRIx64
# define PRIx64 "llx"
# else
// MSVC doesn't have inttypes, nor the PRI?64 defines.
# define PRId64 "I64d"
# define PRIu64 "I64u"
# define PRIx64 "I64x"
# endif // defined(COMP_MINGW)
#endif // COMP_MINGW || COMP_MSC
#define LLD "%" PRId64
#define LLU "%" PRIu64
#if defined(HAVE_NO_INT64_T)
typedef INT64_TYPE int64_t;
#endif
#if defined(HAVE_NO_UINT64_T)
typedef UINT64_TYPE uint64_t;
#endif
#if defined(SYS_WINDOWS)
# define PATHSEP '\\'
#else
# define PATHSEP '/'
#endif
#if defined(WORDS_BIGENDIAN) && (WORDS_BIGENDIAN == 1)
# define ARCH_BIGENDIAN
#else
# define ARCH_LITTLEENDIAN
#endif
#endif
| Java |
/*
* A framebuffer driver for VBE 2.0+ compliant video cards
*
* (c) 2007 Michal Januszewski <spock@gentoo.org>
* Loosely based upon the vesafb driver.
*
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/skbuff.h>
#include <linux/timer.h>
#include <linux/completion.h>
#include <linux/connector.h>
#include <linux/random.h>
#include <linux/platform_device.h>
#include <linux/limits.h>
#include <linux/fb.h>
#include <linux/io.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <video/edid.h>
#include <video/uvesafb.h>
#ifdef CONFIG_X86
#include <video/vga.h>
#include <linux/pci.h>
#endif
#ifdef CONFIG_MTRR
#include <asm/mtrr.h>
#endif
#include "edid.h"
static struct cb_id uvesafb_cn_id = {
.idx = CN_IDX_V86D,
.val = CN_VAL_V86D_UVESAFB
};
static char v86d_path[PATH_MAX] = "/sbin/v86d";
static char v86d_started; /* has v86d been started by uvesafb? */
static struct fb_fix_screeninfo uvesafb_fix __devinitdata = {
.id = "VESA VGA",
.type = FB_TYPE_PACKED_PIXELS,
.accel = FB_ACCEL_NONE,
.visual = FB_VISUAL_TRUECOLOR,
};
static int mtrr __devinitdata = 3; /* enable mtrr by default */
static int blank = 1; /* enable blanking by default */
static int ypan = 1; /* 0: scroll, 1: ypan, 2: ywrap */
static bool pmi_setpal __devinitdata = true; /* use PMI for palette changes */
static int nocrtc __devinitdata; /* ignore CRTC settings */
static int noedid __devinitdata; /* don't try DDC transfers */
static int vram_remap __devinitdata; /* set amt. of memory to be used */
static int vram_total __devinitdata; /* set total amount of memory */
static u16 maxclk __devinitdata; /* maximum pixel clock */
static u16 maxvf __devinitdata; /* maximum vertical frequency */
static u16 maxhf __devinitdata; /* maximum horizontal frequency */
static u16 vbemode __devinitdata; /* force use of a specific VBE mode */
static char *mode_option __devinitdata;
static u8 dac_width = 6;
static struct uvesafb_ktask *uvfb_tasks[UVESAFB_TASKS_MAX];
static DEFINE_MUTEX(uvfb_lock);
/*
* A handler for replies from userspace.
*
* Make sure each message passes consistency checks and if it does,
* find the kernel part of the task struct, copy the registers and
* the buffer contents and then complete the task.
*/
static void uvesafb_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
{
struct uvesafb_task *utask;
struct uvesafb_ktask *task;
if (!cap_raised(current_cap(), CAP_SYS_ADMIN))
return;
if (msg->seq >= UVESAFB_TASKS_MAX)
return;
mutex_lock(&uvfb_lock);
task = uvfb_tasks[msg->seq];
if (!task || msg->ack != task->ack) {
mutex_unlock(&uvfb_lock);
return;
}
utask = (struct uvesafb_task *)msg->data;
/* Sanity checks for the buffer length. */
if (task->t.buf_len < utask->buf_len ||
utask->buf_len > msg->len - sizeof(*utask)) {
mutex_unlock(&uvfb_lock);
return;
}
uvfb_tasks[msg->seq] = NULL;
mutex_unlock(&uvfb_lock);
memcpy(&task->t, utask, sizeof(*utask));
if (task->t.buf_len && task->buf)
memcpy(task->buf, utask + 1, task->t.buf_len);
complete(task->done);
return;
}
static int uvesafb_helper_start(void)
{
char *envp[] = {
"HOME=/",
"PATH=/sbin:/bin",
NULL,
};
char *argv[] = {
v86d_path,
NULL,
};
return call_usermodehelper(v86d_path, argv, envp, 1);
}
/*
* Execute a uvesafb task.
*
* Returns 0 if the task is executed successfully.
*
* A message sent to the userspace consists of the uvesafb_task
* struct and (optionally) a buffer. The uvesafb_task struct is
* a simplified version of uvesafb_ktask (its kernel counterpart)
* containing only the register values, flags and the length of
* the buffer.
*
* Each message is assigned a sequence number (increased linearly)
* and a random ack number. The sequence number is used as a key
* for the uvfb_tasks array which holds pointers to uvesafb_ktask
* structs for all requests.
*/
static int uvesafb_exec(struct uvesafb_ktask *task)
{
static int seq;
struct cn_msg *m;
int err;
int len = sizeof(task->t) + task->t.buf_len;
/*
* Check whether the message isn't longer than the maximum
* allowed by connector.
*/
if (sizeof(*m) + len > CONNECTOR_MAX_MSG_SIZE) {
printk(KERN_WARNING "uvesafb: message too long (%d), "
"can't execute task\n", (int)(sizeof(*m) + len));
return -E2BIG;
}
m = kzalloc(sizeof(*m) + len, GFP_KERNEL);
if (!m)
return -ENOMEM;
init_completion(task->done);
memcpy(&m->id, &uvesafb_cn_id, sizeof(m->id));
m->seq = seq;
m->len = len;
m->ack = random32();
/* uvesafb_task structure */
memcpy(m + 1, &task->t, sizeof(task->t));
/* Buffer */
memcpy((u8 *)(m + 1) + sizeof(task->t), task->buf, task->t.buf_len);
/*
* Save the message ack number so that we can find the kernel
* part of this task when a reply is received from userspace.
*/
task->ack = m->ack;
mutex_lock(&uvfb_lock);
/* If all slots are taken -- bail out. */
if (uvfb_tasks[seq]) {
mutex_unlock(&uvfb_lock);
err = -EBUSY;
goto out;
}
/* Save a pointer to the kernel part of the task struct. */
uvfb_tasks[seq] = task;
mutex_unlock(&uvfb_lock);
err = cn_netlink_send(m, 0, GFP_KERNEL);
if (err == -ESRCH) {
/*
* Try to start the userspace helper if sending
* the request failed the first time.
*/
err = uvesafb_helper_start();
if (err) {
printk(KERN_ERR "uvesafb: failed to execute %s\n",
v86d_path);
printk(KERN_ERR "uvesafb: make sure that the v86d "
"helper is installed and executable\n");
} else {
v86d_started = 1;
err = cn_netlink_send(m, 0, gfp_any());
if (err == -ENOBUFS)
err = 0;
}
} else if (err == -ENOBUFS)
err = 0;
if (!err && !(task->t.flags & TF_EXIT))
err = !wait_for_completion_timeout(task->done,
msecs_to_jiffies(UVESAFB_TIMEOUT));
mutex_lock(&uvfb_lock);
uvfb_tasks[seq] = NULL;
mutex_unlock(&uvfb_lock);
seq++;
if (seq >= UVESAFB_TASKS_MAX)
seq = 0;
out:
kfree(m);
return err;
}
/*
* Free a uvesafb_ktask struct.
*/
static void uvesafb_free(struct uvesafb_ktask *task)
{
if (task) {
if (task->done)
kfree(task->done);
kfree(task);
}
}
/*
* Prepare a uvesafb_ktask struct to be used again.
*/
static void uvesafb_reset(struct uvesafb_ktask *task)
{
struct completion *cpl = task->done;
memset(task, 0, sizeof(*task));
task->done = cpl;
}
/*
* Allocate and prepare a uvesafb_ktask struct.
*/
static struct uvesafb_ktask *uvesafb_prep(void)
{
struct uvesafb_ktask *task;
task = kzalloc(sizeof(*task), GFP_KERNEL);
if (task) {
task->done = kzalloc(sizeof(*task->done), GFP_KERNEL);
if (!task->done) {
kfree(task);
task = NULL;
}
}
return task;
}
static void uvesafb_setup_var(struct fb_var_screeninfo *var,
struct fb_info *info, struct vbe_mode_ib *mode)
{
struct uvesafb_par *par = info->par;
var->vmode = FB_VMODE_NONINTERLACED;
var->sync = FB_SYNC_VERT_HIGH_ACT;
var->xres = mode->x_res;
var->yres = mode->y_res;
var->xres_virtual = mode->x_res;
var->yres_virtual = (par->ypan) ?
info->fix.smem_len / mode->bytes_per_scan_line :
mode->y_res;
var->xoffset = 0;
var->yoffset = 0;
var->bits_per_pixel = mode->bits_per_pixel;
if (var->bits_per_pixel == 15)
var->bits_per_pixel = 16;
if (var->bits_per_pixel > 8) {
var->red.offset = mode->red_off;
var->red.length = mode->red_len;
var->green.offset = mode->green_off;
var->green.length = mode->green_len;
var->blue.offset = mode->blue_off;
var->blue.length = mode->blue_len;
var->transp.offset = mode->rsvd_off;
var->transp.length = mode->rsvd_len;
} else {
var->red.offset = 0;
var->green.offset = 0;
var->blue.offset = 0;
var->transp.offset = 0;
var->red.length = 8;
var->green.length = 8;
var->blue.length = 8;
var->transp.length = 0;
}
}
static int uvesafb_vbe_find_mode(struct uvesafb_par *par,
int xres, int yres, int depth, unsigned char flags)
{
int i, match = -1, h = 0, d = 0x7fffffff;
for (i = 0; i < par->vbe_modes_cnt; i++) {
h = abs(par->vbe_modes[i].x_res - xres) +
abs(par->vbe_modes[i].y_res - yres) +
abs(depth - par->vbe_modes[i].depth);
/*
* We have an exact match in terms of resolution
* and depth.
*/
if (h == 0)
return i;
if (h < d || (h == d && par->vbe_modes[i].depth > depth)) {
d = h;
match = i;
}
}
i = 1;
if (flags & UVESAFB_EXACT_DEPTH &&
par->vbe_modes[match].depth != depth)
i = 0;
if (flags & UVESAFB_EXACT_RES && d > 24)
i = 0;
if (i != 0)
return match;
else
return -1;
}
static u8 *uvesafb_vbe_state_save(struct uvesafb_par *par)
{
struct uvesafb_ktask *task;
u8 *state;
int err;
if (!par->vbe_state_size)
return NULL;
state = kmalloc(par->vbe_state_size, GFP_KERNEL);
if (!state)
return NULL;
task = uvesafb_prep();
if (!task) {
kfree(state);
return NULL;
}
task->t.regs.eax = 0x4f04;
task->t.regs.ecx = 0x000f;
task->t.regs.edx = 0x0001;
task->t.flags = TF_BUF_RET | TF_BUF_ESBX;
task->t.buf_len = par->vbe_state_size;
task->buf = state;
err = uvesafb_exec(task);
if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
printk(KERN_WARNING "uvesafb: VBE get state call "
"failed (eax=0x%x, err=%d)\n",
task->t.regs.eax, err);
kfree(state);
state = NULL;
}
uvesafb_free(task);
return state;
}
static void uvesafb_vbe_state_restore(struct uvesafb_par *par, u8 *state_buf)
{
struct uvesafb_ktask *task;
int err;
if (!state_buf)
return;
task = uvesafb_prep();
if (!task)
return;
task->t.regs.eax = 0x4f04;
task->t.regs.ecx = 0x000f;
task->t.regs.edx = 0x0002;
task->t.buf_len = par->vbe_state_size;
task->t.flags = TF_BUF_ESBX;
task->buf = state_buf;
err = uvesafb_exec(task);
if (err || (task->t.regs.eax & 0xffff) != 0x004f)
printk(KERN_WARNING "uvesafb: VBE state restore call "
"failed (eax=0x%x, err=%d)\n",
task->t.regs.eax, err);
uvesafb_free(task);
}
static int __devinit uvesafb_vbe_getinfo(struct uvesafb_ktask *task,
struct uvesafb_par *par)
{
int err;
task->t.regs.eax = 0x4f00;
task->t.flags = TF_VBEIB;
task->t.buf_len = sizeof(struct vbe_ib);
task->buf = &par->vbe_ib;
strncpy(par->vbe_ib.vbe_signature, "VBE2", 4);
err = uvesafb_exec(task);
if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
printk(KERN_ERR "uvesafb: Getting VBE info block failed "
"(eax=0x%x, err=%d)\n", (u32)task->t.regs.eax,
err);
return -EINVAL;
}
if (par->vbe_ib.vbe_version < 0x0200) {
printk(KERN_ERR "uvesafb: Sorry, pre-VBE 2.0 cards are "
"not supported.\n");
return -EINVAL;
}
if (!par->vbe_ib.mode_list_ptr) {
printk(KERN_ERR "uvesafb: Missing mode list!\n");
return -EINVAL;
}
printk(KERN_INFO "uvesafb: ");
/*
* Convert string pointers and the mode list pointer into
* usable addresses. Print informational messages about the
* video adapter and its vendor.
*/
if (par->vbe_ib.oem_vendor_name_ptr)
printk("%s, ",
((char *)task->buf) + par->vbe_ib.oem_vendor_name_ptr);
if (par->vbe_ib.oem_product_name_ptr)
printk("%s, ",
((char *)task->buf) + par->vbe_ib.oem_product_name_ptr);
if (par->vbe_ib.oem_product_rev_ptr)
printk("%s, ",
((char *)task->buf) + par->vbe_ib.oem_product_rev_ptr);
if (par->vbe_ib.oem_string_ptr)
printk("OEM: %s, ",
((char *)task->buf) + par->vbe_ib.oem_string_ptr);
printk("VBE v%d.%d\n", ((par->vbe_ib.vbe_version & 0xff00) >> 8),
par->vbe_ib.vbe_version & 0xff);
return 0;
}
static int __devinit uvesafb_vbe_getmodes(struct uvesafb_ktask *task,
struct uvesafb_par *par)
{
int off = 0, err;
u16 *mode;
par->vbe_modes_cnt = 0;
/* Count available modes. */
mode = (u16 *) (((u8 *)&par->vbe_ib) + par->vbe_ib.mode_list_ptr);
while (*mode != 0xffff) {
par->vbe_modes_cnt++;
mode++;
}
par->vbe_modes = kzalloc(sizeof(struct vbe_mode_ib) *
par->vbe_modes_cnt, GFP_KERNEL);
if (!par->vbe_modes)
return -ENOMEM;
/* Get info about all available modes. */
mode = (u16 *) (((u8 *)&par->vbe_ib) + par->vbe_ib.mode_list_ptr);
while (*mode != 0xffff) {
struct vbe_mode_ib *mib;
uvesafb_reset(task);
task->t.regs.eax = 0x4f01;
task->t.regs.ecx = (u32) *mode;
task->t.flags = TF_BUF_RET | TF_BUF_ESDI;
task->t.buf_len = sizeof(struct vbe_mode_ib);
task->buf = par->vbe_modes + off;
err = uvesafb_exec(task);
if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
printk(KERN_WARNING "uvesafb: Getting mode info block "
"for mode 0x%x failed (eax=0x%x, err=%d)\n",
*mode, (u32)task->t.regs.eax, err);
mode++;
par->vbe_modes_cnt--;
continue;
}
mib = task->buf;
mib->mode_id = *mode;
/*
* We only want modes that are supported with the current
* hardware configuration, color, graphics and that have
* support for the LFB.
*/
if ((mib->mode_attr & VBE_MODE_MASK) == VBE_MODE_MASK &&
mib->bits_per_pixel >= 8)
off++;
else
par->vbe_modes_cnt--;
mode++;
mib->depth = mib->red_len + mib->green_len + mib->blue_len;
/*
* Handle 8bpp modes and modes with broken color component
* lengths.
*/
if (mib->depth == 0 || (mib->depth == 24 &&
mib->bits_per_pixel == 32))
mib->depth = mib->bits_per_pixel;
}
if (par->vbe_modes_cnt > 0)
return 0;
else
return -EINVAL;
}
/*
* The Protected Mode Interface is 32-bit x86 code, so we only run it on
* x86 and not x86_64.
*/
#ifdef CONFIG_X86_32
static int __devinit uvesafb_vbe_getpmi(struct uvesafb_ktask *task,
struct uvesafb_par *par)
{
int i, err;
uvesafb_reset(task);
task->t.regs.eax = 0x4f0a;
task->t.regs.ebx = 0x0;
err = uvesafb_exec(task);
if ((task->t.regs.eax & 0xffff) != 0x4f || task->t.regs.es < 0xc000) {
par->pmi_setpal = par->ypan = 0;
} else {
par->pmi_base = (u16 *)phys_to_virt(((u32)task->t.regs.es << 4)
+ task->t.regs.edi);
par->pmi_start = (u8 *)par->pmi_base + par->pmi_base[1];
par->pmi_pal = (u8 *)par->pmi_base + par->pmi_base[2];
printk(KERN_INFO "uvesafb: protected mode interface info at "
"%04x:%04x\n",
(u16)task->t.regs.es, (u16)task->t.regs.edi);
printk(KERN_INFO "uvesafb: pmi: set display start = %p, "
"set palette = %p\n", par->pmi_start,
par->pmi_pal);
if (par->pmi_base[3]) {
printk(KERN_INFO "uvesafb: pmi: ports = ");
for (i = par->pmi_base[3]/2;
par->pmi_base[i] != 0xffff; i++)
printk("%x ", par->pmi_base[i]);
printk("\n");
if (par->pmi_base[i] != 0xffff) {
printk(KERN_INFO "uvesafb: can't handle memory"
" requests, pmi disabled\n");
par->ypan = par->pmi_setpal = 0;
}
}
}
return 0;
}
#endif /* CONFIG_X86_32 */
/*
* Check whether a video mode is supported by the Video BIOS and is
* compatible with the monitor limits.
*/
static int __devinit uvesafb_is_valid_mode(struct fb_videomode *mode,
struct fb_info *info)
{
if (info->monspecs.gtf) {
fb_videomode_to_var(&info->var, mode);
if (fb_validate_mode(&info->var, info))
return 0;
}
if (uvesafb_vbe_find_mode(info->par, mode->xres, mode->yres, 8,
UVESAFB_EXACT_RES) == -1)
return 0;
return 1;
}
static int __devinit uvesafb_vbe_getedid(struct uvesafb_ktask *task,
struct fb_info *info)
{
struct uvesafb_par *par = info->par;
int err = 0;
if (noedid || par->vbe_ib.vbe_version < 0x0300)
return -EINVAL;
task->t.regs.eax = 0x4f15;
task->t.regs.ebx = 0;
task->t.regs.ecx = 0;
task->t.buf_len = 0;
task->t.flags = 0;
err = uvesafb_exec(task);
if ((task->t.regs.eax & 0xffff) != 0x004f || err)
return -EINVAL;
if ((task->t.regs.ebx & 0x3) == 3) {
printk(KERN_INFO "uvesafb: VBIOS/hardware supports both "
"DDC1 and DDC2 transfers\n");
} else if ((task->t.regs.ebx & 0x3) == 2) {
printk(KERN_INFO "uvesafb: VBIOS/hardware supports DDC2 "
"transfers\n");
} else if ((task->t.regs.ebx & 0x3) == 1) {
printk(KERN_INFO "uvesafb: VBIOS/hardware supports DDC1 "
"transfers\n");
} else {
printk(KERN_INFO "uvesafb: VBIOS/hardware doesn't support "
"DDC transfers\n");
return -EINVAL;
}
task->t.regs.eax = 0x4f15;
task->t.regs.ebx = 1;
task->t.regs.ecx = task->t.regs.edx = 0;
task->t.flags = TF_BUF_RET | TF_BUF_ESDI;
task->t.buf_len = EDID_LENGTH;
task->buf = kzalloc(EDID_LENGTH, GFP_KERNEL);
err = uvesafb_exec(task);
if ((task->t.regs.eax & 0xffff) == 0x004f && !err) {
fb_edid_to_monspecs(task->buf, &info->monspecs);
if (info->monspecs.vfmax && info->monspecs.hfmax) {
/*
* If the maximum pixel clock wasn't specified in
* the EDID block, set it to 300 MHz.
*/
if (info->monspecs.dclkmax == 0)
info->monspecs.dclkmax = 300 * 1000000;
info->monspecs.gtf = 1;
}
} else {
err = -EINVAL;
}
kfree(task->buf);
return err;
}
static void __devinit uvesafb_vbe_getmonspecs(struct uvesafb_ktask *task,
struct fb_info *info)
{
struct uvesafb_par *par = info->par;
int i;
memset(&info->monspecs, 0, sizeof(info->monspecs));
/*
* If we don't get all necessary data from the EDID block,
* mark it as incompatible with the GTF and set nocrtc so
* that we always use the default BIOS refresh rate.
*/
if (uvesafb_vbe_getedid(task, info)) {
info->monspecs.gtf = 0;
par->nocrtc = 1;
}
/* Kernel command line overrides. */
if (maxclk)
info->monspecs.dclkmax = maxclk * 1000000;
if (maxvf)
info->monspecs.vfmax = maxvf;
if (maxhf)
info->monspecs.hfmax = maxhf * 1000;
/*
* In case DDC transfers are not supported, the user can provide
* monitor limits manually. Lower limits are set to "safe" values.
*/
if (info->monspecs.gtf == 0 && maxclk && maxvf && maxhf) {
info->monspecs.dclkmin = 0;
info->monspecs.vfmin = 60;
info->monspecs.hfmin = 29000;
info->monspecs.gtf = 1;
par->nocrtc = 0;
}
if (info->monspecs.gtf)
printk(KERN_INFO
"uvesafb: monitor limits: vf = %d Hz, hf = %d kHz, "
"clk = %d MHz\n", info->monspecs.vfmax,
(int)(info->monspecs.hfmax / 1000),
(int)(info->monspecs.dclkmax / 1000000));
else
printk(KERN_INFO "uvesafb: no monitor limits have been set, "
"default refresh rate will be used\n");
/* Add VBE modes to the modelist. */
for (i = 0; i < par->vbe_modes_cnt; i++) {
struct fb_var_screeninfo var;
struct vbe_mode_ib *mode;
struct fb_videomode vmode;
mode = &par->vbe_modes[i];
memset(&var, 0, sizeof(var));
var.xres = mode->x_res;
var.yres = mode->y_res;
fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, &var, info);
fb_var_to_videomode(&vmode, &var);
fb_add_videomode(&vmode, &info->modelist);
}
/* Add valid VESA modes to our modelist. */
for (i = 0; i < VESA_MODEDB_SIZE; i++) {
if (uvesafb_is_valid_mode((struct fb_videomode *)
&vesa_modes[i], info))
fb_add_videomode(&vesa_modes[i], &info->modelist);
}
for (i = 0; i < info->monspecs.modedb_len; i++) {
if (uvesafb_is_valid_mode(&info->monspecs.modedb[i], info))
fb_add_videomode(&info->monspecs.modedb[i],
&info->modelist);
}
return;
}
static void __devinit uvesafb_vbe_getstatesize(struct uvesafb_ktask *task,
struct uvesafb_par *par)
{
int err;
uvesafb_reset(task);
/*
* Get the VBE state buffer size. We want all available
* hardware state data (CL = 0x0f).
*/
task->t.regs.eax = 0x4f04;
task->t.regs.ecx = 0x000f;
task->t.regs.edx = 0x0000;
task->t.flags = 0;
err = uvesafb_exec(task);
if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
printk(KERN_WARNING "uvesafb: VBE state buffer size "
"cannot be determined (eax=0x%x, err=%d)\n",
task->t.regs.eax, err);
par->vbe_state_size = 0;
return;
}
par->vbe_state_size = 64 * (task->t.regs.ebx & 0xffff);
}
static int __devinit uvesafb_vbe_init(struct fb_info *info)
{
struct uvesafb_ktask *task = NULL;
struct uvesafb_par *par = info->par;
int err;
task = uvesafb_prep();
if (!task)
return -ENOMEM;
err = uvesafb_vbe_getinfo(task, par);
if (err)
goto out;
err = uvesafb_vbe_getmodes(task, par);
if (err)
goto out;
par->nocrtc = nocrtc;
#ifdef CONFIG_X86_32
par->pmi_setpal = pmi_setpal;
par->ypan = ypan;
if (par->pmi_setpal || par->ypan) {
if (__supported_pte_mask & _PAGE_NX) {
par->pmi_setpal = par->ypan = 0;
printk(KERN_WARNING "uvesafb: NX protection is actively."
"We have better not to use the PMI.\n");
} else {
uvesafb_vbe_getpmi(task, par);
}
}
#else
/* The protected mode interface is not available on non-x86. */
par->pmi_setpal = par->ypan = 0;
#endif
INIT_LIST_HEAD(&info->modelist);
uvesafb_vbe_getmonspecs(task, info);
uvesafb_vbe_getstatesize(task, par);
out: uvesafb_free(task);
return err;
}
static int __devinit uvesafb_vbe_init_mode(struct fb_info *info)
{
struct list_head *pos;
struct fb_modelist *modelist;
struct fb_videomode *mode;
struct uvesafb_par *par = info->par;
int i, modeid;
/* Has the user requested a specific VESA mode? */
if (vbemode) {
for (i = 0; i < par->vbe_modes_cnt; i++) {
if (par->vbe_modes[i].mode_id == vbemode) {
modeid = i;
uvesafb_setup_var(&info->var, info,
&par->vbe_modes[modeid]);
fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60,
&info->var, info);
/*
* With pixclock set to 0, the default BIOS
* timings will be used in set_par().
*/
info->var.pixclock = 0;
goto gotmode;
}
}
printk(KERN_INFO "uvesafb: requested VBE mode 0x%x is "
"unavailable\n", vbemode);
vbemode = 0;
}
/* Count the modes in the modelist */
i = 0;
list_for_each(pos, &info->modelist)
i++;
/*
* Convert the modelist into a modedb so that we can use it with
* fb_find_mode().
*/
mode = kzalloc(i * sizeof(*mode), GFP_KERNEL);
if (mode) {
i = 0;
list_for_each(pos, &info->modelist) {
modelist = list_entry(pos, struct fb_modelist, list);
mode[i] = modelist->mode;
i++;
}
if (!mode_option)
mode_option = UVESAFB_DEFAULT_MODE;
i = fb_find_mode(&info->var, info, mode_option, mode, i,
NULL, 8);
kfree(mode);
}
/* fb_find_mode() failed */
if (i == 0) {
info->var.xres = 640;
info->var.yres = 480;
mode = (struct fb_videomode *)
fb_find_best_mode(&info->var, &info->modelist);
if (mode) {
fb_videomode_to_var(&info->var, mode);
} else {
modeid = par->vbe_modes[0].mode_id;
uvesafb_setup_var(&info->var, info,
&par->vbe_modes[modeid]);
fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60,
&info->var, info);
goto gotmode;
}
}
/* Look for a matching VBE mode. */
modeid = uvesafb_vbe_find_mode(par, info->var.xres, info->var.yres,
info->var.bits_per_pixel, UVESAFB_EXACT_RES);
if (modeid == -1)
return -EINVAL;
uvesafb_setup_var(&info->var, info, &par->vbe_modes[modeid]);
gotmode:
/*
* If we are not VBE3.0+ compliant, we're done -- the BIOS will
* ignore our timings anyway.
*/
if (par->vbe_ib.vbe_version < 0x0300 || par->nocrtc)
fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60,
&info->var, info);
return modeid;
}
static int uvesafb_setpalette(struct uvesafb_pal_entry *entries, int count,
int start, struct fb_info *info)
{
struct uvesafb_ktask *task;
#ifdef CONFIG_X86
struct uvesafb_par *par = info->par;
int i = par->mode_idx;
#endif
int err = 0;
/*
* We support palette modifications for 8 bpp modes only, so
* there can never be more than 256 entries.
*/
if (start + count > 256)
return -EINVAL;
#ifdef CONFIG_X86
/* Use VGA registers if mode is VGA-compatible. */
if (i >= 0 && i < par->vbe_modes_cnt &&
par->vbe_modes[i].mode_attr & VBE_MODE_VGACOMPAT) {
for (i = 0; i < count; i++) {
outb_p(start + i, dac_reg);
outb_p(entries[i].red, dac_val);
outb_p(entries[i].green, dac_val);
outb_p(entries[i].blue, dac_val);
}
}
#ifdef CONFIG_X86_32
else if (par->pmi_setpal) {
__asm__ __volatile__(
"call *(%%esi)"
: /* no return value */
: "a" (0x4f09), /* EAX */
"b" (0), /* EBX */
"c" (count), /* ECX */
"d" (start), /* EDX */
"D" (entries), /* EDI */
"S" (&par->pmi_pal)); /* ESI */
}
#endif /* CONFIG_X86_32 */
else
#endif /* CONFIG_X86 */
{
task = uvesafb_prep();
if (!task)
return -ENOMEM;
task->t.regs.eax = 0x4f09;
task->t.regs.ebx = 0x0;
task->t.regs.ecx = count;
task->t.regs.edx = start;
task->t.flags = TF_BUF_ESDI;
task->t.buf_len = sizeof(struct uvesafb_pal_entry) * count;
task->buf = entries;
err = uvesafb_exec(task);
if ((task->t.regs.eax & 0xffff) != 0x004f)
err = 1;
uvesafb_free(task);
}
return err;
}
static int uvesafb_setcolreg(unsigned regno, unsigned red, unsigned green,
unsigned blue, unsigned transp,
struct fb_info *info)
{
struct uvesafb_pal_entry entry;
int shift = 16 - dac_width;
int err = 0;
if (regno >= info->cmap.len)
return -EINVAL;
if (info->var.bits_per_pixel == 8) {
entry.red = red >> shift;
entry.green = green >> shift;
entry.blue = blue >> shift;
entry.pad = 0;
err = uvesafb_setpalette(&entry, 1, regno, info);
} else if (regno < 16) {
switch (info->var.bits_per_pixel) {
case 16:
if (info->var.red.offset == 10) {
/* 1:5:5:5 */
((u32 *) (info->pseudo_palette))[regno] =
((red & 0xf800) >> 1) |
((green & 0xf800) >> 6) |
((blue & 0xf800) >> 11);
} else {
/* 0:5:6:5 */
((u32 *) (info->pseudo_palette))[regno] =
((red & 0xf800) ) |
((green & 0xfc00) >> 5) |
((blue & 0xf800) >> 11);
}
break;
case 24:
case 32:
red >>= 8;
green >>= 8;
blue >>= 8;
((u32 *)(info->pseudo_palette))[regno] =
(red << info->var.red.offset) |
(green << info->var.green.offset) |
(blue << info->var.blue.offset);
break;
}
}
return err;
}
static int uvesafb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
{
struct uvesafb_pal_entry *entries;
int shift = 16 - dac_width;
int i, err = 0;
if (info->var.bits_per_pixel == 8) {
if (cmap->start + cmap->len > info->cmap.start +
info->cmap.len || cmap->start < info->cmap.start)
return -EINVAL;
entries = kmalloc(sizeof(*entries) * cmap->len, GFP_KERNEL);
if (!entries)
return -ENOMEM;
for (i = 0; i < cmap->len; i++) {
entries[i].red = cmap->red[i] >> shift;
entries[i].green = cmap->green[i] >> shift;
entries[i].blue = cmap->blue[i] >> shift;
entries[i].pad = 0;
}
err = uvesafb_setpalette(entries, cmap->len, cmap->start, info);
kfree(entries);
} else {
/*
* For modes with bpp > 8, we only set the pseudo palette in
* the fb_info struct. We rely on uvesafb_setcolreg to do all
* sanity checking.
*/
for (i = 0; i < cmap->len; i++) {
err |= uvesafb_setcolreg(cmap->start + i, cmap->red[i],
cmap->green[i], cmap->blue[i],
0, info);
}
}
return err;
}
static int uvesafb_pan_display(struct fb_var_screeninfo *var,
struct fb_info *info)
{
#ifdef CONFIG_X86_32
int offset;
struct uvesafb_par *par = info->par;
offset = (var->yoffset * info->fix.line_length + var->xoffset) / 4;
/*
* It turns out it's not the best idea to do panning via vm86,
* so we only allow it if we have a PMI.
*/
if (par->pmi_start) {
__asm__ __volatile__(
"call *(%%edi)"
: /* no return value */
: "a" (0x4f07), /* EAX */
"b" (0), /* EBX */
"c" (offset), /* ECX */
"d" (offset >> 16), /* EDX */
"D" (&par->pmi_start)); /* EDI */
}
#endif
return 0;
}
static int uvesafb_blank(int blank, struct fb_info *info)
{
struct uvesafb_ktask *task;
int err = 1;
#ifdef CONFIG_X86
struct uvesafb_par *par = info->par;
if (par->vbe_ib.capabilities & VBE_CAP_VGACOMPAT) {
int loop = 10000;
u8 seq = 0, crtc17 = 0;
if (blank == FB_BLANK_POWERDOWN) {
seq = 0x20;
crtc17 = 0x00;
err = 0;
} else {
seq = 0x00;
crtc17 = 0x80;
err = (blank == FB_BLANK_UNBLANK) ? 0 : -EINVAL;
}
vga_wseq(NULL, 0x00, 0x01);
seq |= vga_rseq(NULL, 0x01) & ~0x20;
vga_wseq(NULL, 0x00, seq);
crtc17 |= vga_rcrt(NULL, 0x17) & ~0x80;
while (loop--);
vga_wcrt(NULL, 0x17, crtc17);
vga_wseq(NULL, 0x00, 0x03);
} else
#endif /* CONFIG_X86 */
{
task = uvesafb_prep();
if (!task)
return -ENOMEM;
task->t.regs.eax = 0x4f10;
switch (blank) {
case FB_BLANK_UNBLANK:
task->t.regs.ebx = 0x0001;
break;
case FB_BLANK_NORMAL:
task->t.regs.ebx = 0x0101; /* standby */
break;
case FB_BLANK_POWERDOWN:
task->t.regs.ebx = 0x0401; /* powerdown */
break;
default:
goto out;
}
err = uvesafb_exec(task);
if (err || (task->t.regs.eax & 0xffff) != 0x004f)
err = 1;
out: uvesafb_free(task);
}
return err;
}
static int uvesafb_open(struct fb_info *info, int user)
{
struct uvesafb_par *par = info->par;
int cnt = atomic_read(&par->ref_count);
if (!cnt && par->vbe_state_size)
par->vbe_state_orig = uvesafb_vbe_state_save(par);
atomic_inc(&par->ref_count);
return 0;
}
static int uvesafb_release(struct fb_info *info, int user)
{
struct uvesafb_ktask *task = NULL;
struct uvesafb_par *par = info->par;
int cnt = atomic_read(&par->ref_count);
if (!cnt)
return -EINVAL;
if (cnt != 1)
goto out;
task = uvesafb_prep();
if (!task)
goto out;
/* First, try to set the standard 80x25 text mode. */
task->t.regs.eax = 0x0003;
uvesafb_exec(task);
/*
* Now try to restore whatever hardware state we might have
* saved when the fb device was first opened.
*/
uvesafb_vbe_state_restore(par, par->vbe_state_orig);
out:
atomic_dec(&par->ref_count);
if (task)
uvesafb_free(task);
return 0;
}
static int uvesafb_set_par(struct fb_info *info)
{
struct uvesafb_par *par = info->par;
struct uvesafb_ktask *task = NULL;
struct vbe_crtc_ib *crtc = NULL;
struct vbe_mode_ib *mode = NULL;
int i, err = 0, depth = info->var.bits_per_pixel;
if (depth > 8 && depth != 32)
depth = info->var.red.length + info->var.green.length +
info->var.blue.length;
i = uvesafb_vbe_find_mode(par, info->var.xres, info->var.yres, depth,
UVESAFB_EXACT_RES | UVESAFB_EXACT_DEPTH);
if (i >= 0)
mode = &par->vbe_modes[i];
else
return -EINVAL;
task = uvesafb_prep();
if (!task)
return -ENOMEM;
setmode:
task->t.regs.eax = 0x4f02;
task->t.regs.ebx = mode->mode_id | 0x4000; /* use LFB */
if (par->vbe_ib.vbe_version >= 0x0300 && !par->nocrtc &&
info->var.pixclock != 0) {
task->t.regs.ebx |= 0x0800; /* use CRTC data */
task->t.flags = TF_BUF_ESDI;
crtc = kzalloc(sizeof(struct vbe_crtc_ib), GFP_KERNEL);
if (!crtc) {
err = -ENOMEM;
goto out;
}
crtc->horiz_start = info->var.xres + info->var.right_margin;
crtc->horiz_end = crtc->horiz_start + info->var.hsync_len;
crtc->horiz_total = crtc->horiz_end + info->var.left_margin;
crtc->vert_start = info->var.yres + info->var.lower_margin;
crtc->vert_end = crtc->vert_start + info->var.vsync_len;
crtc->vert_total = crtc->vert_end + info->var.upper_margin;
crtc->pixel_clock = PICOS2KHZ(info->var.pixclock) * 1000;
crtc->refresh_rate = (u16)(100 * (crtc->pixel_clock /
(crtc->vert_total * crtc->horiz_total)));
if (info->var.vmode & FB_VMODE_DOUBLE)
crtc->flags |= 0x1;
if (info->var.vmode & FB_VMODE_INTERLACED)
crtc->flags |= 0x2;
if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT))
crtc->flags |= 0x4;
if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT))
crtc->flags |= 0x8;
memcpy(&par->crtc, crtc, sizeof(*crtc));
} else {
memset(&par->crtc, 0, sizeof(*crtc));
}
task->t.buf_len = sizeof(struct vbe_crtc_ib);
task->buf = &par->crtc;
err = uvesafb_exec(task);
if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
/*
* The mode switch might have failed because we tried to
* use our own timings. Try again with the default timings.
*/
if (crtc != NULL) {
printk(KERN_WARNING "uvesafb: mode switch failed "
"(eax=0x%x, err=%d). Trying again with "
"default timings.\n", task->t.regs.eax, err);
uvesafb_reset(task);
kfree(crtc);
crtc = NULL;
info->var.pixclock = 0;
goto setmode;
} else {
printk(KERN_ERR "uvesafb: mode switch failed (eax="
"0x%x, err=%d)\n", task->t.regs.eax, err);
err = -EINVAL;
goto out;
}
}
par->mode_idx = i;
/* For 8bpp modes, always try to set the DAC to 8 bits. */
if (par->vbe_ib.capabilities & VBE_CAP_CAN_SWITCH_DAC &&
mode->bits_per_pixel <= 8) {
uvesafb_reset(task);
task->t.regs.eax = 0x4f08;
task->t.regs.ebx = 0x0800;
err = uvesafb_exec(task);
if (err || (task->t.regs.eax & 0xffff) != 0x004f ||
((task->t.regs.ebx & 0xff00) >> 8) != 8) {
dac_width = 6;
} else {
dac_width = 8;
}
}
info->fix.visual = (info->var.bits_per_pixel == 8) ?
FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
info->fix.line_length = mode->bytes_per_scan_line;
out: if (crtc != NULL)
kfree(crtc);
uvesafb_free(task);
return err;
}
static void uvesafb_check_limits(struct fb_var_screeninfo *var,
struct fb_info *info)
{
const struct fb_videomode *mode;
struct uvesafb_par *par = info->par;
/*
* If pixclock is set to 0, then we're using default BIOS timings
* and thus don't have to perform any checks here.
*/
if (!var->pixclock)
return;
if (par->vbe_ib.vbe_version < 0x0300) {
fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 60, var, info);
return;
}
if (!fb_validate_mode(var, info))
return;
mode = fb_find_best_mode(var, &info->modelist);
if (mode) {
if (mode->xres == var->xres && mode->yres == var->yres &&
!(mode->vmode & (FB_VMODE_INTERLACED | FB_VMODE_DOUBLE))) {
fb_videomode_to_var(var, mode);
return;
}
}
if (info->monspecs.gtf && !fb_get_mode(FB_MAXTIMINGS, 0, var, info))
return;
/* Use default refresh rate */
var->pixclock = 0;
}
static int uvesafb_check_var(struct fb_var_screeninfo *var,
struct fb_info *info)
{
struct uvesafb_par *par = info->par;
struct vbe_mode_ib *mode = NULL;
int match = -1;
int depth = var->red.length + var->green.length + var->blue.length;
/*
* Various apps will use bits_per_pixel to set the color depth,
* which is theoretically incorrect, but which we'll try to handle
* here.
*/
if (depth == 0 || abs(depth - var->bits_per_pixel) >= 8)
depth = var->bits_per_pixel;
match = uvesafb_vbe_find_mode(par, var->xres, var->yres, depth,
UVESAFB_EXACT_RES);
if (match == -1)
return -EINVAL;
mode = &par->vbe_modes[match];
uvesafb_setup_var(var, info, mode);
/*
* Check whether we have remapped enough memory for this mode.
* We might be called at an early stage, when we haven't remapped
* any memory yet, in which case we simply skip the check.
*/
if (var->yres * mode->bytes_per_scan_line > info->fix.smem_len
&& info->fix.smem_len)
return -EINVAL;
if ((var->vmode & FB_VMODE_DOUBLE) &&
!(par->vbe_modes[match].mode_attr & 0x100))
var->vmode &= ~FB_VMODE_DOUBLE;
if ((var->vmode & FB_VMODE_INTERLACED) &&
!(par->vbe_modes[match].mode_attr & 0x200))
var->vmode &= ~FB_VMODE_INTERLACED;
uvesafb_check_limits(var, info);
var->xres_virtual = var->xres;
var->yres_virtual = (par->ypan) ?
info->fix.smem_len / mode->bytes_per_scan_line :
var->yres;
return 0;
}
static struct fb_ops uvesafb_ops = {
.owner = THIS_MODULE,
.fb_open = uvesafb_open,
.fb_release = uvesafb_release,
.fb_setcolreg = uvesafb_setcolreg,
.fb_setcmap = uvesafb_setcmap,
.fb_pan_display = uvesafb_pan_display,
.fb_blank = uvesafb_blank,
.fb_fillrect = cfb_fillrect,
.fb_copyarea = cfb_copyarea,
.fb_imageblit = cfb_imageblit,
.fb_check_var = uvesafb_check_var,
.fb_set_par = uvesafb_set_par,
};
static void __devinit uvesafb_init_info(struct fb_info *info,
struct vbe_mode_ib *mode)
{
unsigned int size_vmode;
unsigned int size_remap;
unsigned int size_total;
struct uvesafb_par *par = info->par;
int i, h;
info->pseudo_palette = ((u8 *)info->par + sizeof(struct uvesafb_par));
info->fix = uvesafb_fix;
info->fix.ypanstep = par->ypan ? 1 : 0;
info->fix.ywrapstep = (par->ypan > 1) ? 1 : 0;
/* Disable blanking if the user requested so. */
if (!blank)
info->fbops->fb_blank = NULL;
/*
* Find out how much IO memory is required for the mode with
* the highest resolution.
*/
size_remap = 0;
for (i = 0; i < par->vbe_modes_cnt; i++) {
h = par->vbe_modes[i].bytes_per_scan_line *
par->vbe_modes[i].y_res;
if (h > size_remap)
size_remap = h;
}
size_remap *= 2;
/*
* size_vmode -- that is the amount of memory needed for the
* used video mode, i.e. the minimum amount of
* memory we need.
*/
if (mode != NULL) {
size_vmode = info->var.yres * mode->bytes_per_scan_line;
} else {
size_vmode = info->var.yres * info->var.xres *
((info->var.bits_per_pixel + 7) >> 3);
}
/*
* size_total -- all video memory we have. Used for mtrr
* entries, resource allocation and bounds
* checking.
*/
size_total = par->vbe_ib.total_memory * 65536;
if (vram_total)
size_total = vram_total * 1024 * 1024;
if (size_total < size_vmode)
size_total = size_vmode;
/*
* size_remap -- the amount of video memory we are going to
* use for vesafb. With modern cards it is no
* option to simply use size_total as th
* wastes plenty of kernel address space.
*/
if (vram_remap)
size_remap = vram_remap * 1024 * 1024;
if (size_remap < size_vmode)
size_remap = size_vmode;
if (size_remap > size_total)
size_remap = size_total;
info->fix.smem_len = size_remap;
info->fix.smem_start = mode->phys_base_ptr;
/*
* We have to set yres_virtual here because when setup_var() was
* called, smem_len wasn't defined yet.
*/
info->var.yres_virtual = info->fix.smem_len /
mode->bytes_per_scan_line;
if (par->ypan && info->var.yres_virtual > info->var.yres) {
printk(KERN_INFO "uvesafb: scrolling: %s "
"using protected mode interface, "
"yres_virtual=%d\n",
(par->ypan > 1) ? "ywrap" : "ypan",
info->var.yres_virtual);
} else {
printk(KERN_INFO "uvesafb: scrolling: redraw\n");
info->var.yres_virtual = info->var.yres;
par->ypan = 0;
}
info->flags = FBINFO_FLAG_DEFAULT |
(par->ypan ? FBINFO_HWACCEL_YPAN : 0);
if (!par->ypan)
info->fbops->fb_pan_display = NULL;
}
static void __devinit uvesafb_init_mtrr(struct fb_info *info)
{
#ifdef CONFIG_MTRR
if (mtrr && !(info->fix.smem_start & (PAGE_SIZE - 1))) {
int temp_size = info->fix.smem_len;
unsigned int type = 0;
switch (mtrr) {
case 1:
type = MTRR_TYPE_UNCACHABLE;
break;
case 2:
type = MTRR_TYPE_WRBACK;
break;
case 3:
type = MTRR_TYPE_WRCOMB;
break;
case 4:
type = MTRR_TYPE_WRTHROUGH;
break;
default:
type = 0;
break;
}
if (type) {
int rc;
/* Find the largest power-of-two */
temp_size = roundup_pow_of_two(temp_size);
/* Try and find a power of two to add */
do {
rc = mtrr_add(info->fix.smem_start,
temp_size, type, 1);
temp_size >>= 1;
} while (temp_size >= PAGE_SIZE && rc == -EINVAL);
}
}
#endif /* CONFIG_MTRR */
}
static void __devinit uvesafb_ioremap(struct fb_info *info)
{
#ifdef CONFIG_X86
switch (mtrr) {
case 1: /* uncachable */
info->screen_base = ioremap_nocache(info->fix.smem_start, info->fix.smem_len);
break;
case 2: /* write-back */
info->screen_base = ioremap_cache(info->fix.smem_start, info->fix.smem_len);
break;
case 3: /* write-combining */
info->screen_base = ioremap_wc(info->fix.smem_start, info->fix.smem_len);
break;
case 4: /* write-through */
default:
info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
break;
}
#else
info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
#endif /* CONFIG_X86 */
}
static ssize_t uvesafb_show_vbe_ver(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
return snprintf(buf, PAGE_SIZE, "%.4x\n", par->vbe_ib.vbe_version);
}
static DEVICE_ATTR(vbe_version, S_IRUGO, uvesafb_show_vbe_ver, NULL);
static ssize_t uvesafb_show_vbe_modes(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
int ret = 0, i;
for (i = 0; i < par->vbe_modes_cnt && ret < PAGE_SIZE; i++) {
ret += snprintf(buf + ret, PAGE_SIZE - ret,
"%dx%d-%d, 0x%.4x\n",
par->vbe_modes[i].x_res, par->vbe_modes[i].y_res,
par->vbe_modes[i].depth, par->vbe_modes[i].mode_id);
}
return ret;
}
static DEVICE_ATTR(vbe_modes, S_IRUGO, uvesafb_show_vbe_modes, NULL);
static ssize_t uvesafb_show_vendor(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (par->vbe_ib.oem_vendor_name_ptr)
return snprintf(buf, PAGE_SIZE, "%s\n", (char *)
(&par->vbe_ib) + par->vbe_ib.oem_vendor_name_ptr);
else
return 0;
}
static DEVICE_ATTR(oem_vendor, S_IRUGO, uvesafb_show_vendor, NULL);
static ssize_t uvesafb_show_product_name(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (par->vbe_ib.oem_product_name_ptr)
return snprintf(buf, PAGE_SIZE, "%s\n", (char *)
(&par->vbe_ib) + par->vbe_ib.oem_product_name_ptr);
else
return 0;
}
static DEVICE_ATTR(oem_product_name, S_IRUGO, uvesafb_show_product_name, NULL);
static ssize_t uvesafb_show_product_rev(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (par->vbe_ib.oem_product_rev_ptr)
return snprintf(buf, PAGE_SIZE, "%s\n", (char *)
(&par->vbe_ib) + par->vbe_ib.oem_product_rev_ptr);
else
return 0;
}
static DEVICE_ATTR(oem_product_rev, S_IRUGO, uvesafb_show_product_rev, NULL);
static ssize_t uvesafb_show_oem_string(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (par->vbe_ib.oem_string_ptr)
return snprintf(buf, PAGE_SIZE, "%s\n",
(char *)(&par->vbe_ib) + par->vbe_ib.oem_string_ptr);
else
return 0;
}
static DEVICE_ATTR(oem_string, S_IRUGO, uvesafb_show_oem_string, NULL);
static ssize_t uvesafb_show_nocrtc(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
return snprintf(buf, PAGE_SIZE, "%d\n", par->nocrtc);
}
static ssize_t uvesafb_store_nocrtc(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (count > 0) {
if (buf[0] == '0')
par->nocrtc = 0;
else
par->nocrtc = 1;
}
return count;
}
static DEVICE_ATTR(nocrtc, S_IRUGO | S_IWUSR, uvesafb_show_nocrtc,
uvesafb_store_nocrtc);
static struct attribute *uvesafb_dev_attrs[] = {
&dev_attr_vbe_version.attr,
&dev_attr_vbe_modes.attr,
&dev_attr_oem_vendor.attr,
&dev_attr_oem_product_name.attr,
&dev_attr_oem_product_rev.attr,
&dev_attr_oem_string.attr,
&dev_attr_nocrtc.attr,
NULL,
};
static struct attribute_group uvesafb_dev_attgrp = {
.name = NULL,
.attrs = uvesafb_dev_attrs,
};
static int __devinit uvesafb_probe(struct platform_device *dev)
{
struct fb_info *info;
struct vbe_mode_ib *mode = NULL;
struct uvesafb_par *par;
int err = 0, i;
info = framebuffer_alloc(sizeof(*par) + sizeof(u32) * 256, &dev->dev);
if (!info)
return -ENOMEM;
par = info->par;
err = uvesafb_vbe_init(info);
if (err) {
printk(KERN_ERR "uvesafb: vbe_init() failed with %d\n", err);
goto out;
}
info->fbops = &uvesafb_ops;
i = uvesafb_vbe_init_mode(info);
if (i < 0) {
err = -EINVAL;
goto out;
} else {
mode = &par->vbe_modes[i];
}
if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
err = -ENXIO;
goto out;
}
uvesafb_init_info(info, mode);
if (!request_region(0x3c0, 32, "uvesafb")) {
printk(KERN_ERR "uvesafb: request region 0x3c0-0x3e0 failed\n");
err = -EIO;
goto out_mode;
}
if (!request_mem_region(info->fix.smem_start, info->fix.smem_len,
"uvesafb")) {
printk(KERN_ERR "uvesafb: cannot reserve video memory at "
"0x%lx\n", info->fix.smem_start);
err = -EIO;
goto out_reg;
}
uvesafb_init_mtrr(info);
uvesafb_ioremap(info);
if (!info->screen_base) {
printk(KERN_ERR
"uvesafb: abort, cannot ioremap 0x%x bytes of video "
"memory at 0x%lx\n",
info->fix.smem_len, info->fix.smem_start);
err = -EIO;
goto out_mem;
}
platform_set_drvdata(dev, info);
if (register_framebuffer(info) < 0) {
printk(KERN_ERR
"uvesafb: failed to register framebuffer device\n");
err = -EINVAL;
goto out_unmap;
}
printk(KERN_INFO "uvesafb: framebuffer at 0x%lx, mapped to 0x%p, "
"using %dk, total %dk\n", info->fix.smem_start,
info->screen_base, info->fix.smem_len/1024,
par->vbe_ib.total_memory * 64);
printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
info->fix.id);
err = sysfs_create_group(&dev->dev.kobj, &uvesafb_dev_attgrp);
if (err != 0)
printk(KERN_WARNING "fb%d: failed to register attributes\n",
info->node);
return 0;
out_unmap:
iounmap(info->screen_base);
out_mem:
release_mem_region(info->fix.smem_start, info->fix.smem_len);
out_reg:
release_region(0x3c0, 32);
out_mode:
if (!list_empty(&info->modelist))
fb_destroy_modelist(&info->modelist);
fb_destroy_modedb(info->monspecs.modedb);
fb_dealloc_cmap(&info->cmap);
out:
if (par->vbe_modes)
kfree(par->vbe_modes);
framebuffer_release(info);
return err;
}
static int uvesafb_remove(struct platform_device *dev)
{
struct fb_info *info = platform_get_drvdata(dev);
if (info) {
struct uvesafb_par *par = info->par;
sysfs_remove_group(&dev->dev.kobj, &uvesafb_dev_attgrp);
unregister_framebuffer(info);
release_region(0x3c0, 32);
iounmap(info->screen_base);
release_mem_region(info->fix.smem_start, info->fix.smem_len);
fb_destroy_modedb(info->monspecs.modedb);
fb_dealloc_cmap(&info->cmap);
if (par) {
if (par->vbe_modes)
kfree(par->vbe_modes);
if (par->vbe_state_orig)
kfree(par->vbe_state_orig);
if (par->vbe_state_saved)
kfree(par->vbe_state_saved);
}
framebuffer_release(info);
}
return 0;
}
static struct platform_driver uvesafb_driver = {
.probe = uvesafb_probe,
.remove = uvesafb_remove,
.driver = {
.name = "uvesafb",
},
};
static struct platform_device *uvesafb_device;
#ifndef MODULE
static int __devinit uvesafb_setup(char *options)
{
char *this_opt;
if (!options || !*options)
return 0;
while ((this_opt = strsep(&options, ",")) != NULL) {
if (!*this_opt) continue;
if (!strcmp(this_opt, "redraw"))
ypan = 0;
else if (!strcmp(this_opt, "ypan"))
ypan = 1;
else if (!strcmp(this_opt, "ywrap"))
ypan = 2;
else if (!strcmp(this_opt, "vgapal"))
pmi_setpal = 0;
else if (!strcmp(this_opt, "pmipal"))
pmi_setpal = 1;
else if (!strncmp(this_opt, "mtrr:", 5))
mtrr = simple_strtoul(this_opt+5, NULL, 0);
else if (!strcmp(this_opt, "nomtrr"))
mtrr = 0;
else if (!strcmp(this_opt, "nocrtc"))
nocrtc = 1;
else if (!strcmp(this_opt, "noedid"))
noedid = 1;
else if (!strcmp(this_opt, "noblank"))
blank = 0;
else if (!strncmp(this_opt, "vtotal:", 7))
vram_total = simple_strtoul(this_opt + 7, NULL, 0);
else if (!strncmp(this_opt, "vremap:", 7))
vram_remap = simple_strtoul(this_opt + 7, NULL, 0);
else if (!strncmp(this_opt, "maxhf:", 6))
maxhf = simple_strtoul(this_opt + 6, NULL, 0);
else if (!strncmp(this_opt, "maxvf:", 6))
maxvf = simple_strtoul(this_opt + 6, NULL, 0);
else if (!strncmp(this_opt, "maxclk:", 7))
maxclk = simple_strtoul(this_opt + 7, NULL, 0);
else if (!strncmp(this_opt, "vbemode:", 8))
vbemode = simple_strtoul(this_opt + 8, NULL, 0);
else if (this_opt[0] >= '0' && this_opt[0] <= '9') {
mode_option = this_opt;
} else {
printk(KERN_WARNING
"uvesafb: unrecognized option %s\n", this_opt);
}
}
return 0;
}
#endif /* !MODULE */
static ssize_t show_v86d(struct device_driver *dev, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", v86d_path);
}
static ssize_t store_v86d(struct device_driver *dev, const char *buf,
size_t count)
{
strncpy(v86d_path, buf, PATH_MAX);
return count;
}
static DRIVER_ATTR(v86d, S_IRUGO | S_IWUSR, show_v86d, store_v86d);
static int __devinit uvesafb_init(void)
{
int err;
#ifndef MODULE
char *option = NULL;
if (fb_get_options("uvesafb", &option))
return -ENODEV;
uvesafb_setup(option);
#endif
err = cn_add_callback(&uvesafb_cn_id, "uvesafb", uvesafb_cn_callback);
if (err)
return err;
err = platform_driver_register(&uvesafb_driver);
if (!err) {
uvesafb_device = platform_device_alloc("uvesafb", 0);
if (uvesafb_device)
err = platform_device_add(uvesafb_device);
else
err = -ENOMEM;
if (err) {
platform_device_put(uvesafb_device);
platform_driver_unregister(&uvesafb_driver);
cn_del_callback(&uvesafb_cn_id);
return err;
}
err = driver_create_file(&uvesafb_driver.driver,
&driver_attr_v86d);
if (err) {
printk(KERN_WARNING "uvesafb: failed to register "
"attributes\n");
err = 0;
}
}
return err;
}
module_init(uvesafb_init);
static void __devexit uvesafb_exit(void)
{
struct uvesafb_ktask *task;
if (v86d_started) {
task = uvesafb_prep();
if (task) {
task->t.flags = TF_EXIT;
uvesafb_exec(task);
uvesafb_free(task);
}
}
cn_del_callback(&uvesafb_cn_id);
driver_remove_file(&uvesafb_driver.driver, &driver_attr_v86d);
platform_device_unregister(uvesafb_device);
platform_driver_unregister(&uvesafb_driver);
}
module_exit(uvesafb_exit);
static int param_set_scroll(const char *val, const struct kernel_param *kp)
{
ypan = 0;
if (!strcmp(val, "redraw"))
ypan = 0;
else if (!strcmp(val, "ypan"))
ypan = 1;
else if (!strcmp(val, "ywrap"))
ypan = 2;
else
return -EINVAL;
return 0;
}
static struct kernel_param_ops param_ops_scroll = {
.set = param_set_scroll,
};
#define param_check_scroll(name, p) __param_check(name, p, void)
module_param_named(scroll, ypan, scroll, 0);
MODULE_PARM_DESC(scroll,
"Scrolling mode, set to 'redraw', 'ypan', or 'ywrap'");
module_param_named(vgapal, pmi_setpal, invbool, 0);
MODULE_PARM_DESC(vgapal, "Set palette using VGA registers");
module_param_named(pmipal, pmi_setpal, bool, 0);
MODULE_PARM_DESC(pmipal, "Set palette using PMI calls");
module_param(mtrr, uint, 0);
MODULE_PARM_DESC(mtrr,
"Memory Type Range Registers setting. Use 0 to disable.");
module_param(blank, bool, 0);
MODULE_PARM_DESC(blank, "Enable hardware blanking");
module_param(nocrtc, bool, 0);
MODULE_PARM_DESC(nocrtc, "Ignore CRTC timings when setting modes");
module_param(noedid, bool, 0);
MODULE_PARM_DESC(noedid,
"Ignore EDID-provided monitor limits when setting modes");
module_param(vram_remap, uint, 0);
MODULE_PARM_DESC(vram_remap, "Set amount of video memory to be used [MiB]");
module_param(vram_total, uint, 0);
MODULE_PARM_DESC(vram_total, "Set total amount of video memoery [MiB]");
module_param(maxclk, ushort, 0);
MODULE_PARM_DESC(maxclk, "Maximum pixelclock [MHz], overrides EDID data");
module_param(maxhf, ushort, 0);
MODULE_PARM_DESC(maxhf,
"Maximum horizontal frequency [kHz], overrides EDID data");
module_param(maxvf, ushort, 0);
MODULE_PARM_DESC(maxvf,
"Maximum vertical frequency [Hz], overrides EDID data");
module_param(mode_option, charp, 0);
MODULE_PARM_DESC(mode_option,
"Specify initial video mode as \"<xres>x<yres>[-<bpp>][@<refresh>]\"");
module_param(vbemode, ushort, 0);
MODULE_PARM_DESC(vbemode,
"VBE mode number to set, overrides the 'mode' option");
module_param_string(v86d, v86d_path, PATH_MAX, 0660);
MODULE_PARM_DESC(v86d, "Path to the v86d userspace helper.");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Michal Januszewski <spock@gentoo.org>");
MODULE_DESCRIPTION("Framebuffer driver for VBE2.0+ compliant graphics boards");
| Java |
/**
* 对公众平台发送给公众账号的消息加解密示例代码.
*
* @copyright Copyright (c) 1998-2014 Tencent Inc.
*/
// ------------------------------------------------------------------------
package com.weixin.sdk.encrypt;
import java.security.MessageDigest;
import java.util.Arrays;
/**
* SHA1 class
*
* 计算公众平台的消息签名接口.
*/
class SHA1 {
/**
* 用SHA1算法生成安全签名
* @param token 票据
* @param timestamp 时间戳
* @param nonce 随机字符串
* @param encrypt 密文
* @return 安全签名
* @throws AesException
*/
public static String getSHA1(String token, String timestamp, String nonce, String encrypt) throws AesException
{
try {
String[] array = new String[] { token, timestamp, nonce, encrypt };
StringBuffer sb = new StringBuffer();
// 字符串排序
Arrays.sort(array);
for (int i = 0; i < 4; i++) {
sb.append(array[i]);
}
String str = sb.toString();
// SHA1签名生成
MessageDigest md = MessageDigest.getInstance("SHA-1");
md.update(str.getBytes());
byte[] digest = md.digest();
StringBuffer hexstr = new StringBuffer();
String shaHex = "";
for (int i = 0; i < digest.length; i++) {
shaHex = Integer.toHexString(digest[i] & 0xFF);
if (shaHex.length() < 2) {
hexstr.append(0);
}
hexstr.append(shaHex);
}
return hexstr.toString();
} catch (Exception e) {
e.printStackTrace();
throw new AesException(AesException.ComputeSignatureError);
}
}
}
| Java |
/*
Copyright (C) 2015 Panagiotis Roubatsis
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.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
/*
* Created by Panagiotis Roubatsis
*
* Description: A single adjacency for the adjacency list.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Map_Creator
{
class MapAdjacency
{
public int destIndex;
public int cost;
public bool invisible;
public MapAdjacency(int dest, int cost, bool invisible)
{
this.destIndex = dest;
this.cost = cost;
this.invisible = invisible;
}
}
}
| Java |
set term ^;
CREATE OR ALTER PROCEDURE RELDRE( PDTA1 DATE
, PDTA2 DATE, PCC INTEGER )
-- ATS Soluções 11/03/2009
RETURNS ( CONTA VARCHAR( 30 )
, DESC_CONTA VARCHAR( 80 )
, CREDITO DOUBLE PRECISION
, TOTAL DOUBLE PRECISION
, ACUMULA DOUBLE PRECISION
, TOT CHAR( 1 ) )
AS
DECLARE VARIABLE CODREC INTEGER;
DECLARE VARIABLE CODP INTEGER;
DECLARE VARIABLE CENTROPERDA INTEGER;
DECLARE VARIABLE CONTAJURO VARCHAR(60);
DECLARE VARIABLE CONTAPASSIVO VARCHAR(60);
DECLARE VARIABLE CONTACOMISSAO integer; -- Codigo da Conta
DECLARE VARIABLE CONTAIMPOSTOVENDA integer; -- Codigo da Conta
DECLARE VARIABLE TOTALIZA Double precision;
DECLARE VARIABLE TOTALREC Double precision = 0;
DECLARE VARIABLE TOTAL Double precision = 0;
DECLARE VARIABLE custoMatPrima Double precision = 0;
DECLARE VARIABLE QTDE Double precision = 0;
DECLARE VARIABLE produt VARCHAR(300);
DECLARE VARIABLE linha VARCHAR(60);
DECLARE VARIABLE jaPassou CHAR(1);
DECLARE VARIABLE CONTAPAI VARCHAR(15);
DECLARE VARIABLE EstoqueIni Double precision = 0;
DECLARE VARIABLE EstoqueFim Double precision = 0;
DECLARE VARIABLE Compras Double precision = 0;
DECLARE VARIABLE Desconto Double precision = 0;
BEGIN
-- TOT -----> A = Negrito / Valor Null, S = Negrito com Valor, N = Normal sem valor
linha = 'nada';
jaPassou = 'N';
/* Busca o CENTRO DE CUSTO usado para Lixo e Descartes */
SELECT DADOS FROM PARAMETRO WHERE PARAMETRO = 'CENTRO PERDA'
INTO :CENTROPERDA;
IF (CENTROPERDA IS NULL) THEN
CENTROPERDA = 0;
/* Busca a Conta Principal de lançamento Desp. Juros. */
CONTAJURO = '4.1.1.01';
SELECT DADOS FROM PARAMETRO WHERE PARAMETRO = 'CONTASDESPESAJUROS'
INTO :CONTAJURO;
/* Busca a Conta Principal de lançamento Desp. COMISSAO. */
contaComissao = null;
SELECT CAST(DADOS as INTEGER) FROM PARAMETRO WHERE PARAMETRO = 'CONTACOMISSAO'
INTO :CONTACOMISSAO;
IF (CONTACOMISSAO IS NULL) THEN
CONTACOMISSAO = 0;
/* Busca a Conta PASSIVO. */
contaPassivo = null;
SELECT CAST(DADOS as INTEGER) FROM PARAMETRO WHERE PARAMETRO = 'CONTASPASSIVO'
INTO :CONTAPASSIVO;
IF (CONTAPASSIVO IS NULL) THEN
CONTAPASSIVO = 0;
/* Busca a Conta Principal de lançamento Impostos Sobre Venda*/
contaImpostoVenda = null;
SELECT CAST(DADOS as INTEGER) FROM PARAMETRO WHERE PARAMETRO = 'CONTAIMPOSTOVENDA'
INTO :CONTAIMPOSTOVENDA;
/* ########### Gerando a Receita ############*/
/* Receitas Vendas OS */
DESC_CONTA = 'Receitas operacionais';
CONTA = null;
CREDITO = null;
SUSPEND;
TOTALIZA = 0;
TOTAL = 0;
select sum(md.valTotal)
FROM MOVIMENTO mov
inner join MOVIMENTODETALHE md on md.CODMOVIMENTO = mov.CODMOVIMENTO
inner join VENDA ven on ven.CODMOVIMENTO = mov.CODMOVIMENTO
inner join PRODUTOS prod on prod.CODPRODUTO = md.CODPRODUTO
where (mov.codnatureza = 3)
and (ven.DATAVENDA between :PDTA1 AND :PDTA2)
and ((PROD.TIPO <> 'SERV') OR (PROD.TIPO IS NULL))
and ((ven.CODCCUSTO = :PCC) OR (:PCC = 0))
INTO :CREDITO;
select sum(md.valTotal*((case when md.qtde_alt is null then 0 else md.qtde_alt end)/100))
FROM MOVIMENTO mov
inner join MOVIMENTODETALHE md on md.CODMOVIMENTO = mov.CODMOVIMENTO
inner join VENDA ven on ven.CODMOVIMENTO = mov.CODMOVIMENTO
inner join PRODUTOS prod on prod.CODPRODUTO = md.CODPRODUTO
where (mov.codnatureza = 3) and (ven.DATAVENDA between :PDTA1 AND :PDTA2)
and ((PROD.TIPO <> 'SERV') OR (PROD.TIPO IS NULL)) and ((ven.CODCCUSTO = :PCC) OR (:PCC = 0))
INTO :desconto;
if (desconto is null) then
desconto = 0;
IF (CREDITO IS NULL) THEN
CREDITO = 0;
CREDITO = CREDITO-desconto;
DESC_CONTA = ' Faturamento do Mês';
TOTALIZA = TOTALIZA + CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
SUSPEND;
TOTALIZA = 0;
/* Receitas Servicos OS */
CONTA = null;
CREDITO = null;
TOTALIZA = 0;
FOR select sum(md.valTotal)
FROM MOVIMENTO mov
inner join MOVIMENTODETALHE md on md.CODMOVIMENTO = mov.CODMOVIMENTO
inner join VENDA ven on ven.CODMOVIMENTO = mov.CODMOVIMENTO
inner join PRODUTOS prod on prod.CODPRODUTO = md.CODPRODUTO
where (mov.codnatureza = 3) and (ven.DATAVENDA between :PDTA1 AND :PDTA2)
and PROD.TIPO = 'SERV' and ((ven.CODCCUSTO = :PCC) OR (:PCC = 0))
INTO :CREDITO
do begin
IF (CREDITO IS NULL) THEN
CREDITO = 0;
DESC_CONTA = ' Receitas de Serviços ';
TOTALIZA = TOTALIZA + CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
if (CREDITO > 0) THEN
SUSPEND;
end
/* Receitas Vendas OS */
DESC_CONTA = 'Receitas não operacionais';
CONTA = null;
CREDITO = null;
TOT = 'A';
SUSPEND;
/* Receitas JUROS e CORRECAO MONETARIA*/
CONTA = null;
CREDITO = null;
TOTALIZA = 0;
FOR select sum(JUROS + FUNRURAL)
FROM RECEBIMENTO rec
where (rec.DATARECEBIMENTO between :PDTA1 AND :PDTA2) and rec.STATUS = '7-'
INTO :CREDITO
do begin
IF (CREDITO IS NULL) THEN
CREDITO = 0;
DESC_CONTA = ' Receitas de Juros e Corr. Monetária ';
TOTALIZA = TOTALIZA + CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
if (CREDITO > 0) THEN
SUSPEND;
end
TOTALIZA = 0;
-- Outras Receitas de Vendas (FRETE , SEGUROS, etc )
FOR select sum(v.VALOR_FRETE + v.VALOR_SEGURO + v.OUTRAS_DESP + v.VALOR_IPI)
FROM VENDA v
where (v.DATAVENDA between :PDTA1 AND :PDTA2)
INTO :CREDITO
do begin
IF (CREDITO IS NULL) THEN
CREDITO = 0;
DESC_CONTA = ' Outros receitas (FRETE, SEGURO) ';
TOTALIZA = TOTALIZA + CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
if (CREDITO > 0) THEN
SUSPEND;
end
TOTALIZA = 0;
-- Receitas Diversas
FOR select sum(r.VALOR_RESTO), p.NOME
FROM RECEBIMENTO r
inner join plano p on p.CODIGO = r.CONTACREDITO
where (r.EMISSAO between :PDTA1 AND :PDTA2) And (r.CODVENDA is null)
group by p.NOME
INTO :CREDITO, :DESC_CONTA
do begin
DESC_CONTA = ' ' || :DESC_CONTA;
IF (CREDITO IS NULL) THEN
CREDITO = 0;
TOTALIZA = TOTALIZA + CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
if (CREDITO > 0) THEN
SUSPEND;
TOTALIZA = 0;
end
DESC_CONTA = '= Total de Receitas ';
CONTA = null;
CREDITO = null;
--TOTAL = NULL;
TOT = 'S';
SUSPEND;
TOTALIZA = 0;
/* Gerando Total Receita */
DESC_CONTA = '(-) Deduções das Receitas';
CONTA = null;
CREDITO = null;
ACUMULA = TOTAL;
TOTAL = 0;
TOT = 'A';
SUSPEND;
/* COMISSAO DE VENDAS */
IF (CONTACOMISSAO IS NOT NULL) THEN
begin
For Select sum(pag.VALOR_RESTO), pl.NOME
FROM PAGAMENTO pag , plano pl
where (pag.EMISSAO between :PDTA1 AND :PDTA2) and pl.CODIGO = pag.CONTACREDITO
and (pag.CONTACREDITO = :CONTACOMISSAO) group by pl.NOME
INTO :CREDITO, :DESC_CONTA
do begin
desc_conta = ' ' || :DESC_CONTA;
IF (CREDITO IS NULL) THEN
CREDITO = 0;
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
if (CREDITO > 0) THEN
SUSPEND;
end
end
/* Deducoes das Receitas*/
CONTA = null;
CREDITO = null;
TOTALIZA = 0;
TOTAL = ACUMULA;
-- Desconto concedido na venda
FOR select sum(ven.DESCONTO)
FROM VENDA ven
where (ven.DATAVENDA between :PDTA1 AND :PDTA2) and ((ven.CODCCUSTO = :PCC) OR (:PCC = 0))
INTO :CREDITO
do begin
IF (CREDITO IS NULL) THEN
CREDITO = 0;
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
IF (CREDITO > 0) then
SUSPEND;
end
/* PERDAS E DESCARTES*/
CONTA = null;
CREDITO = null;
TOTALIZA = 0;
TOTAL = ACUMULA;
FOR select sum(md.VLRESTOQUE)
FROM MOVIMENTO mov
inner join MOVIMENTODETALHE md on md.CODMOVIMENTO = mov.CODMOVIMENTO
inner join PRODUTOS prod on prod.CODPRODUTO = md.CODPRODUTO
where (mov.codnatureza = 2) and (mov.DATAMOVIMENTO between :PDTA1 AND :PDTA2)
and ((mov.CODALMOXARIFADO = :CENTROPERDA))
INTO :CREDITO
do begin
IF (CREDITO IS NULL) THEN
CREDITO = 0;
DESC_CONTA = ' Perdas e Descartes';
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
IF (CREDITO > 0) then
SUSPEND;
end
/* Impostos sobre Venda */
IF (CONTAIMPOSTOVENDA IS NOT NULL) THEN
begin
For Select sum(pag.VALOR_RESTO), pl.NOME
FROM PAGAMENTO pag , plano pl
where (pag.EMISSAO between :PDTA1 AND :PDTA2) and pl.CODIGO = pag.CONTACREDITO
and (pag.CONTACREDITO = :CONTAIMPOSTOVENDA) group by pl.NOME
INTO :CREDITO, :DESC_CONTA
do begin
desc_conta = ' ' || :DESC_CONTA;
IF (CREDITO IS NULL) THEN
CREDITO = 0;
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
if (CREDITO > 0) THEN
SUSPEND;
end
end
DESC_CONTA = '= Receitas Líquidas';
CONTA = null;
CREDITO = null;
TOTAL = ACUMULA;
--TOTAL = NULL;
TOT = 'S';
SUSPEND;
/* ########### FIM Receita ############*/
/* ########### Gerando a Despesas ############*/
DESC_CONTA = '(-) Custo das Vendas';
CONTA = null;
CREDITO = null;
TOT = 'N';
SUSPEND;
TOTALIZA = 0;
Select sum(VALORCUSTO*SALDOFIM) from SPESTOQUEPRODUTO((:PDTA1-30), (:PDTA1-1),0,500000, 'TODOS OS GRUPOS CADASTRADOS',
'TODOS SUBGRUPOS DO CADASTRO', 'TODAS AS MARCAS CADASTRADAS', 0)
INTO :EstoqueIni;
TOTALIZA = EstoqueFim;
Select sum(VALORCUSTO*SALDOFIM) from SPESTOQUEPRODUTO(:PDTA1, :PDTA2,0,500000, 'TODOS OS GRUPOS CADASTRADOS',
'TODOS SUBGRUPOS DO CADASTRO', 'TODAS AS MARCAS CADASTRADAS', 0)
INTO :EstoqueFim;
TOTALIZA = TOTALIZA + EstoqueFim;
EstoqueFim = TOTALIZA;
TOTALIZA = 0;
/* Valor que Entrou durante o Mês por Compras*/
For select SUM(rec.VALOR) from COMPRA rec
where rec.DATACOMPRA between :PDTA1 and :PDTA2
and rec.codFORNECEDOR > 0
and ((rec.CODCCUSTO = :PCC) OR (:PCC = 0))
INTO :Compras
do begin
end
EstoqueFim = EstoqueIni + Compras;
DESC_CONTA = ' Custo dos Produtos Vendidos';
CREDITO = EstoqueIni + Compras - EstoqueFim;
TOTALIZA = TOTALIZA - CREDITO;
--TOTAL = TOTAL + TOTALIZA; ############# Aqui esta pegando algum valor NULL
ACUMULA = TOTAL;
TOT = 'N';
if (CREDITO > 0) then
SUSPEND;
TOTALIZA = 0;
DESC_CONTA = ' Estoque Inicial';
CREDITO = estoqueIni;
TOT = 'N';
--if (CREDITO > 0) then
-- SUSPEND;
DESC_CONTA = ' Compras';
if (compras is null) then
compras = 0;
CREDITO = Compras;
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = TOTAL + TOTALIZA;
TOT = 'N';
if (CREDITO > 0) then
SUSPEND;
compras = 0;
TOTALIZA = 0;
DESC_CONTA = ' Estoque Final';
CREDITO = EstoqueFim;
TOT = 'N';
--if (CREDITO > 0) then
-- SUSPEND;
TOTALIZA = 0;
CONTA = null;
CREDITO = null;
TOTALIZA = 0;
-- Serviços
FOR select sum(md.QUANTIDADE * prod.PRECOMEDIO)
FROM MOVIMENTO mov
inner join MOVIMENTODETALHE md on md.CODMOVIMENTO = mov.CODMOVIMENTO
inner join VENDA ven on ven.CODMOVIMENTO = mov.CODMOVIMENTO
inner join PRODUTOS prod on prod.CODPRODUTO = md.CODPRODUTO
inner join NATUREZAOPERACAO natu on natu.CODNATUREZA = mov.CODNATUREZA
where (natu.TIPOMOVIMENTO = 3)
and (ven.DATAVENDA between :PDTA1 AND :PDTA2)
and prod.TIPO = 'SERV'
and ((ven.CODCCUSTO = :PCC) OR (:PCC = 0))
INTO :CREDITO
do begin
IF (CREDITO IS NULL) THEN
CREDITO = 0;
DESC_CONTA = ' Custo dos Serviços Vendidos';
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
if (CREDITO > 0) then
SUSPEND;
end
TOTALIZA = 0;
-- ##################### Busca as contas que estão marcadas para reduzir da Receita
FOR select distinct pl.contapai FROM PAGAMENTO pag
left outer join COMPRA cp on cp.CODCOMPRA = pag.CODCOMPRA
inner join plano pl on pl.CODIGO = pag.CONTACREDITO
where (pl.REDUZRECEITA = 'S')
and (pag.EMISSAO between :PDTA1 AND :PDTA2)
and ((pag.CODALMOXARIFADO = :PCC) OR (:PCC = 0))
and (pl.CODIGO <> :CONTACOMISSAO)
and (pl.CONTAPAI <> '')
and (plnCtaRoot(pl.CONTAPAI) <> 2)
group by pl.contapai
INTO :CONTAPAI
do begin
TOT = 'G'; /*Para nao imprimir a linha*/
TOTAL = 0;
CONTA = null;
CREDITO = null;
SELECT NOME FROM PLANO WHERE CONTA = :CONTAPAI
INTO :DESC_CONTA;
-- SUSPEND; -- Nao imprimi esse grupos , aparecem tudo em Custos de Vendas
TOTAL = ACUMULA;
/* A maioria das despesas nao tem produto, sao compras ligado ao plano de contas */
FOR select sum(pag.VALOR_RESTO), pl.NOME
FROM PAGAMENTO pag
left outer join COMPRA cp on cp.CODCOMPRA = pag.CODCOMPRA
inner join plano pl on pl.CODIGO = pag.CONTACREDITO
where (pl.REDUZRECEITA = 'S')
and (pag.EMISSAO between :PDTA1 AND :PDTA2)
and pl.contapai = :CONTAPAI
and ((pag.CODALMOXARIFADO = :PCC) OR (:PCC = 0))
and (plnCtaRoot(pl.CONTAPAI) <> 2)
group by pl.NOME
INTO :CREDITO, :produt
do begin
if (credito is null) then
credito = 0;
DESC_CONTA = ' ' || produt;
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
SUSPEND;
TOTALIZA = 0;
end
end
-- ########################## Fim do REDUZ RECEITA
DESC_CONTA = '= Resultado Bruto';
CONTA = null;
CREDITO = null;
TOTALIZA = 0;
--TOTAL = 0;
TOT = 'S';
TOTAL = ACUMULA;
SUSPEND;
ACUMULA = TOTAL;
DESC_CONTA = '(-) Despesas Operacionais';
CONTA = null;
CREDITO = null;
TOT = 'N';
SUSPEND;
/* PEGO A CONTA PAI PARA IMPRIMIR POR GRUPO */
FOR select distinct pl.contapai
FROM PAGAMENTO pag
left outer join COMPRA cp on cp.CODCOMPRA = pag.CODCOMPRA
inner join plano pl on pl.CODIGO = pag.CONTACREDITO
where ((REDUZRECEITA IS NULL) OR (REDUZRECEITA = 'N'))
and (pag.EMISSAO between :PDTA1 AND :PDTA2)
and ((pag.CODALMOXARIFADO = :PCC) OR (:PCC = 0))
and (plnCtaRoot(pl.CONTAPAI) <> 2)
and (pl.CODIGO <> :CONTACOMISSAO)
and (pl.CONTAPAI <> '')
group by pl.contapai
INTO :CONTAPAI
do begin
TOT = 'G'; /*Para nao imprimir a linha*/
TOTAL = 0;
CONTA = null;
CREDITO = null;
SELECT NOME FROM PLANO WHERE CONTA = :CONTAPAI
INTO :DESC_CONTA;
if (plnctaRoot(:contaPai) <> contaPassivo ) then
begin
SUSPEND;
end
if (jaPassou = 'N') then
begin
IF (CONTAPAI = CONTAJURO) THEN
begin
--desc_conta = :CONTAPAI || ' - ' || :CONTAJURO;
--suspend;
For Select sum(pag.JUROS + pag.FUNRURAL)
FROM PAGAMENTO pag
where (pag.DATAPAGAMENTO between :PDTA1 AND :PDTA2)
and pag.STATUS = '7-'
and ((pag.CODALMOXARIFADO = :PCC) OR (:PCC = 0))
INTO :CREDITO
do begin
IF (CREDITO IS NULL) THEN
CREDITO = 0;
DESC_CONTA = ' Despesas Juros e Corr. Monetária ';
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = ACUMULA;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
if (credito > 0) then
SUSPEND;
end
jaPassou = 'S';
end
end
TOTAL = ACUMULA;
ACUMULA = 0;
if (plnctaRoot(:contaPai) <> contaPassivo ) then
begin
/* A maioria das despesas nao tem produto, sao compras ligado ao plano de contas */
FOR select sum(pag.VALOR_RESTO), pl.NOME
FROM PAGAMENTO pag
left outer join COMPRA cp on cp.CODCOMPRA = pag.CODCOMPRA
inner join plano pl on pl.CODIGO = pag.CONTACREDITO
where ((REDUZRECEITA IS NULL) OR (REDUZRECEITA = 'N'))
and (pag.EMISSAO between :PDTA1 AND :PDTA2)
and pl.contapai = :CONTAPAI
and ((pag.CODALMOXARIFADO = :PCC) OR (:PCC = 0))
and (plnCtaRoot(pl.CONTAPAI) <> 2)
group by pl.NOME
INTO :CREDITO, :produt
do
begin
if (credito is null) then
credito = 0;
DESC_CONTA = ' ' || produt;
TOTALIZA = TOTALIZA - CREDITO;
TOTAL = TOTAL + TOTALIZA;
ACUMULA = TOTAL;
TOT = 'N';
SUSPEND;
TOTALIZA = 0;
end
end
TOTALIZA = 0;
end
/* Gerando Total Receita */
DESC_CONTA = '= Resultado Liquido ';
CONTA = null;
CREDITO = null;
--TOTAL = TOTALIZA;
TOT = 'S';
SUSPEND;
--TOTAL = ACUMULA + TOTALIZA;
/* Resultado Geral do Período */
DESC_CONTA = ' Resultado Geral no período : ';
CONTA = null;
CREDITO = null;
--TOTAL = TOTALREC - TOTALIZA;
SUSPEND;
TOTAL = null;
end
| Java |
package com.rockey.emonitor.jms.controller;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
import com.rockey.emonitor.jms.component.AppList;
import com.rockey.emonitor.jms.component.EmonitorContext;
import com.rockey.emonitor.jms.component.FilterList;
import com.rockey.emonitor.jms.model.LogMessage;
import com.rockey.emonitor.jms.service.MessageService;
import com.rockey.emonitor.jms.util.Base64;
import com.rockey.emonitor.jms.util.Util;
import com.rockey.emonitor.model.AppFilter;
public class MessageController extends AbstractController{
private static final Log log = LogFactory.getLog(MessageController.class);
@Autowired
private MessageService messageService;
@Autowired
private EmonitorContext runtimeContext;
@Autowired
private AppList appListComponent;
@Autowired
private FilterList filterListComponent;
private String key;
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest request,
HttpServletResponse response) throws Exception {
request.setCharacterEncoding("utf-8");
log.info("requestURL =[ " + request.getRequestURI() + "?" + request.getQueryString() + " ]");
if (!runtimeContext.isReadyProcess()) {
log.error("EmonitorContext not init complete ! please wait...");
return null;
}
try {
List<String> appList = appListComponent.getAppList();
Map<String, List<AppFilter>> filterMap = filterListComponent.getFilterMap();
Map<String,String> params = new HashMap<String,String>();
// 打印参数列表
@SuppressWarnings("unchecked")
Enumeration<String> names = request.getParameterNames();
if(names.hasMoreElements())
{
while (names.hasMoreElements()) {
String paramName = (String) names.nextElement();
String paramValue = request.getParameter(paramName);
//将所有参数转为大写
params.put(paramName.toUpperCase(), paramValue);
log.info("Request Parameter：" + paramName + "=" + paramValue);
}
}
//获取消息
String message = params.get("MESSAGE");
if (message!= null && !message.isEmpty()) {
message = new String(Base64.decode(message.getBytes("UTF-8")),"UTF-8");
}
log.info("client IP :" + request.getRemoteAddr() + ", message = " + message);
LogMessage logMessage = Util.createMessageFromXml(message);
//密钥检测
String sign = Util.ComputeHash(logMessage, this.key);
if (logMessage.getSign().equals(sign)) {
if (!appList.isEmpty() && appList.contains(logMessage.getApplicationID())) {//应用合法检测
if (!filterMap.isEmpty() && filterMap.containsKey(logMessage.getApplicationID())) {//过滤器检测
List<AppFilter> fiterList = filterMap.get(logMessage.getApplicationID());
for (AppFilter filter : fiterList) {
if (logMessage.getTitle().contains(filter.getContent())) {
log.info("告警标题包含过滤信息[" + filter.getContent() + "],信息将会被过滤。");
return null;
}
if (logMessage.getBody().contains(filter.getContent())) {
log.info("告警内容包含过滤信息[" + filter.getContent() + "],信息将会被过滤。");
return null;
}
}
}
messageService.sendAlertMessage(logMessage);
} else {
log.error("invalid applicationId (" + logMessage.getApplicationID() + ") ....");
}
}
} catch (Exception e) {
log.error("MessageController err", e);
}
return null;
}
}
| Java |
#!/usr/bin/perl
use strict;
use lib "$ENV{'LJHOME'}/cgi-bin";
use LJ;
my $dbh = LJ::get_dbh("master");
my $sth;
$sth = $dbh->prepare("SELECT spid FROM support WHERE timelasthelp IS NULL");
$sth->execute;
while (my ($spid) = $sth->fetchrow_array)
{
print "Fixing $spid...\n";
my $st2 = $dbh->prepare("SELECT MAX(timelogged) FROM supportlog WHERE spid=$spid AND type='answer'");
$st2->execute;
my ($max) = $st2->fetchrow_array;
$max = $max + 0; # turn undef -> 0
print " time = $max\n";
$dbh->do("UPDATE support SET timelasthelp=$max WHERE spid=$spid");
}
| Java |
//------------------------------------------------------------------------------
// <自动生成>
// 此代码由工具生成。
//
// 对此文件的更改可能会导致不正确的行为，并且如果
// 重新生成代码，这些更改将会丢失。
// </自动生成>
//------------------------------------------------------------------------------
namespace FormsAuthWeb {
public partial class MyInfo {
}
}
| Java |
<?php
if ( ! defined( 'ABSPATH' ) ) {
exit; // disable direct access
}
if ( ! class_exists( 'Mega_Menu_Nav_Menus' ) ) :
/**
* Handles all admin related functionality.
*/
class Mega_Menu_Nav_Menus {
/**
* Return the default settings for each menu item
*
* @since 1.5
*/
public static function get_menu_item_defaults() {
$defaults = array(
'type' => 'flyout',
'align' => 'bottom-left',
'icon' => 'disabled',
'hide_text' => 'false',
'disable_link' => 'false',
'hide_arrow' => 'false',
'item_align' => 'left',
'panel_columns' => 6, // total number of columns displayed in the panel
'mega_menu_columns' => 1 // for sub menu items, how many columns to span in the panel
);
return apply_filters( "megamenu_menu_item_defaults", $defaults );
}
/**
* Constructor
*
* @since 1.0
*/
public function __construct() {
add_action( 'admin_init', array( $this, 'register_nav_meta_box' ), 11 );
add_action( 'admin_enqueue_scripts', array( $this, 'enqueue_menu_page_scripts' ) );
add_action( 'megamenu_save_settings', array($this, 'save') );
add_filter( 'hidden_meta_boxes', array( $this, 'show_mega_menu_metabox' ) );
}
/**
* By default the mega menu meta box is hidden - show it.
*
* @since 1.0
* @param array $hidden
* @return array
*/
public function show_mega_menu_metabox( $hidden ) {
if ( is_array( $hidden ) && count( $hidden ) > 0 ) {
foreach ( $hidden as $key => $value ) {
if ( $value == 'mega_menu_meta_box' ) {
unset( $hidden[$key] );
}
}
}
return $hidden;
}
/**
* Adds the meta box container
*
* @since 1.0
*/
public function register_nav_meta_box() {
global $pagenow;
if ( 'nav-menus.php' == $pagenow ) {
add_meta_box(
'mega_menu_meta_box',
__("Mega Menu Settings", "megamenu"),
array( $this, 'metabox_contents' ),
'nav-menus',
'side',
'high'
);
}
}
/**
* Enqueue required CSS and JS for Mega Menu
*
* @since 1.0
*/
public function enqueue_menu_page_scripts($hook) {
if( 'nav-menus.php' != $hook )
return;
// http://wordpress.org/plugins/image-widget/
if ( class_exists( 'Tribe_Image_Widget' ) ) {
$image_widget = new Tribe_Image_Widget;
$image_widget->admin_setup();
}
wp_enqueue_style( 'colorbox', MEGAMENU_BASE_URL . 'js/colorbox/colorbox.css', false, MEGAMENU_VERSION );
wp_enqueue_style( 'mega-menu', MEGAMENU_BASE_URL . 'css/admin-menus.css', false, MEGAMENU_VERSION );
wp_enqueue_script( 'mega-menu', MEGAMENU_BASE_URL . 'js/admin.js', array(
'jquery',
'jquery-ui-core',
'jquery-ui-sortable',
'jquery-ui-accordion'),
MEGAMENU_VERSION );
wp_enqueue_script( 'colorbox', MEGAMENU_BASE_URL . 'js/colorbox/jquery.colorbox-min.js', array( 'jquery' ), MEGAMENU_VERSION );
wp_localize_script( 'mega-menu', 'megamenu',
array(
'debug_launched' => __("Launched for Menu ID", "megamenu"),
'launch_lightbox' => __("Mega Menu", "megamenu"),
'saving' => __("Saving", "megamenu"),
'nonce' => wp_create_nonce('megamenu_edit'),
'nonce_check_failed' => __("Oops. Something went wrong. Please reload the page.", "megamenu")
)
);
do_action("megamenu_enqueue_admin_scripts");
}
/**
* Show the Meta Menu settings
*
* @since 1.0
*/
public function metabox_contents() {
$menu_id = $this->get_selected_menu_id();
do_action("megamenu_save_settings");
$this->print_enable_megamenu_options( $menu_id );
}
/**
* Save the mega menu settings (submitted from Menus Page Meta Box)
*
* @since 1.0
*/
public function save() {
if ( isset( $_POST['menu'] ) && $_POST['menu'] > 0 && is_nav_menu( $_POST['menu'] ) && isset( $_POST['megamenu_meta'] ) ) {
$submitted_settings = $_POST['megamenu_meta'];
if ( ! get_site_option( 'megamenu_settings' ) ) {
add_site_option( 'megamenu_settings', $submitted_settings );
} else {
$existing_settings = get_site_option( 'megamenu_settings' );
$new_settings = array_merge( $existing_settings, $submitted_settings );
update_site_option( 'megamenu_settings', $new_settings );
}
do_action( "megamenu_after_save_settings" );
}
}
/**
* Print the custom Meta Box settings
*
* @param int $menu_id
* @since 1.0
*/
public function print_enable_megamenu_options( $menu_id ) {
$tagged_menu_locations = $this->get_tagged_theme_locations_for_menu_id( $menu_id );
$theme_locations = get_registered_nav_menus();
$saved_settings = get_site_option( 'megamenu_settings' );
if ( ! count( $theme_locations ) ) {
echo "<p>" . __("This theme does not have any menu locations.", "megamenu") . "</p>";
} else if ( ! count ( $tagged_menu_locations ) ) {
echo "<p>" . __("This menu is not tagged to a location. Please tag a location to enable the Mega Menu settings.", "megamenu") . "</p>";
} else { ?>
<?php if ( count( $tagged_menu_locations ) == 1 ) : ?>
<?php
$locations = array_keys( $tagged_menu_locations );
$location = $locations[0];
if (isset( $tagged_menu_locations[ $location ] ) ) {
$this->settings_table( $location, $saved_settings );
}
?>
<?php else: ?>
<div id='megamenu_accordion'>
<?php foreach ( $theme_locations as $location => $name ) : ?>
<?php if ( isset( $tagged_menu_locations[ $location ] ) ): ?>
<h3 class='theme_settings'><?php echo esc_html( $name ); ?></h3>
<div class='accordion_content' style='display: none;'>
<?php $this->settings_table( $location, $saved_settings ); ?>
</div>
<?php endif; ?>
<?php endforeach;?>
</div>
<?php endif; ?>
<?php
submit_button( __( 'Save' ), 'button-primary alignright');
}
}
/**
* Print the list of Mega Menu settings
*
* @since 1.0
*/
public function settings_table( $location, $settings ) {
?>
<table>
<tr>
<td><?php _e("Enable", "megamenu") ?></td>
<td>
<input type='checkbox' name='megamenu_meta[<?php echo $location ?>][enabled]' value='1' <?php checked( isset( $settings[$location]['enabled'] ) ); ?> />
</td>
</tr>
<tr>
<td><?php _e("Event", "megamenu") ?></td>
<td>
<select name='megamenu_meta[<?php echo $location ?>][event]'>
<option value='hover' <?php selected( isset( $settings[$location]['event'] ) && $settings[$location]['event'] == 'hover'); ?>><?php _e("Hover", "megamenu"); ?></option>
<option value='click' <?php selected( isset( $settings[$location]['event'] ) && $settings[$location]['event'] == 'click'); ?>><?php _e("Click", "megamenu"); ?></option>
</select>
</td>
</tr>
<tr>
<td><?php _e("Effect", "megamenu") ?></td>
<td>
<select name='megamenu_meta[<?php echo $location ?>][effect]'>
<?php
$selected = isset( $settings[$location]['effect'] ) ? $settings[$location]['effect'] : 'disabled';
$options = apply_filters("megamenu_effects", array(
"disabled" => array(
'label' => __("None", "megamenu"),
'selected' => $selected == 'disabled',
),
"fade" => array(
'label' => __("Fade", "megamenu"),
'selected' => $selected == 'fade',
),
"slide" => array(
'label' => __("Slide", "megamenu"),
'selected' => $selected == 'slide',
)
), $selected );
foreach ( $options as $key => $value ) {
?><option value='<?php echo $key ?>' <?php selected( $value['selected'] ); ?>><?php echo $value['label'] ?></option><?php
}
?>
</select>
</td>
</tr>
<tr>
<td><?php _e("Theme", "megamenu"); ?></td>
<td>
<select name='megamenu_meta[<?php echo $location ?>][theme]'>
<?php
$style_manager = new Mega_Menu_Style_Manager();
$themes = $style_manager->get_themes();
foreach ( $themes as $key => $theme ) {
echo "<option value='{$key}' " . selected( $settings[$location]['theme'], $key ) . ">{$theme['title']}</option>";
}
?>
</select>
</td>
</tr>
<?php do_action('megamenu_settings_table', $location, $settings); ?>
</table>
<?php
}
/**
* Return the locations that a specific menu ID has been tagged to.
*
* @param $menu_id int
* @return array
*/
public function get_tagged_theme_locations_for_menu_id( $menu_id ) {
$locations = array();
$nav_menu_locations = get_nav_menu_locations();
foreach ( get_registered_nav_menus() as $id => $name ) {
if ( isset( $nav_menu_locations[ $id ] ) && $nav_menu_locations[$id] == $menu_id )
$locations[$id] = $name;
}
return $locations;
}
/**
* Get the current menu ID.
*
* Most of this taken from wp-admin/nav-menus.php (no built in functions to do this)
*
* @since 1.0
* @return int
*/
public function get_selected_menu_id() {
$nav_menus = wp_get_nav_menus( array('orderby' => 'name') );
$menu_count = count( $nav_menus );
$nav_menu_selected_id = isset( $_REQUEST['menu'] ) ? (int) $_REQUEST['menu'] : 0;
$add_new_screen = ( isset( $_GET['menu'] ) && 0 == $_GET['menu'] ) ? true : false;
// If we have one theme location, and zero menus, we take them right into editing their first menu
$page_count = wp_count_posts( 'page' );
$one_theme_location_no_menus = ( 1 == count( get_registered_nav_menus() ) && ! $add_new_screen && empty( $nav_menus ) && ! empty( $page_count->publish ) ) ? true : false;
// Get recently edited nav menu
$recently_edited = absint( get_user_option( 'nav_menu_recently_edited' ) );
if ( empty( $recently_edited ) && is_nav_menu( $nav_menu_selected_id ) )
$recently_edited = $nav_menu_selected_id;
// Use $recently_edited if none are selected
if ( empty( $nav_menu_selected_id ) && ! isset( $_GET['menu'] ) && is_nav_menu( $recently_edited ) )
$nav_menu_selected_id = $recently_edited;
// On deletion of menu, if another menu exists, show it
if ( ! $add_new_screen && 0 < $menu_count && isset( $_GET['action'] ) && 'delete' == $_GET['action'] )
$nav_menu_selected_id = $nav_menus[0]->term_id;
// Set $nav_menu_selected_id to 0 if no menus
if ( $one_theme_location_no_menus ) {
$nav_menu_selected_id = 0;
} elseif ( empty( $nav_menu_selected_id ) && ! empty( $nav_menus ) && ! $add_new_screen ) {
// if we have no selection yet, and we have menus, set to the first one in the list
$nav_menu_selected_id = $nav_menus[0]->term_id;
}
return $nav_menu_selected_id;
}
}
endif; | Java |
using System;
namespace Player.Model
{
/// <remarks>
/// A button can only be rectangular, if there should be other forms, you have to use more buttons which reference each other.
/// </remarks>
public interface ButtonPosition
{
int X { get; }
int Y { get; }
/// <summary>The dimension in x coordinates, i.e. how many columns are allocated.</summary>
int DimX { get; }
/// <summary>The dimension in y coordinates, i.e. how many rows are allocated.</summary>
int DimY { get; }
}
}
| Java |
/*
* Copyright (C) 2011-2021 Project SkyFire <https://www.projectskyfire.org/>
* Copyright (C) 2008-2021 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2021 MaNGOS <https://www.getmangos.eu/>
* Copyright (C) 2006-2014 ScriptDev2 <https://github.com/scriptdev2/scriptdev2/>
*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
/* ScriptData
SDName: Shattrath_City
SD%Complete: 100
SDComment: Quest support: 10004, 10009, 10211. Flask vendors, Teleport to Caverns of Time
SDCategory: Shattrath City
EndScriptData */
/* ContentData
npc_raliq_the_drunk
npc_salsalabim
npc_shattrathflaskvendors
npc_zephyr
npc_kservant
npc_ishanah
npc_khadgar
EndContentData */
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ScriptedGossip.h"
#include "ScriptedEscortAI.h"
#include "Player.h"
#include "WorldSession.h"
/*######
## npc_raliq_the_drunk
######*/
#define GOSSIP_RALIQ "You owe Sim'salabim money. Hand them over or die!"
enum Raliq
{
SPELL_UPPERCUT = 10966,
QUEST_CRACK_SKULLS = 10009,
FACTION_HOSTILE_RD = 45
};
class npc_raliq_the_drunk : public CreatureScript
{
public:
npc_raliq_the_drunk() : CreatureScript("npc_raliq_the_drunk") { }
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) OVERRIDE
{
player->PlayerTalkClass->ClearMenus();
if (action == GOSSIP_ACTION_INFO_DEF+1)
{
player->CLOSE_GOSSIP_MENU();
creature->setFaction(FACTION_HOSTILE_RD);
creature->AI()->AttackStart(player);
}
return true;
}
bool OnGossipHello(Player* player, Creature* creature) OVERRIDE
{
if (player->GetQuestStatus(QUEST_CRACK_SKULLS) == QUEST_STATUS_INCOMPLETE)
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_VENDOR, GOSSIP_RALIQ, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
player->SEND_GOSSIP_MENU(9440, creature->GetGUID());
return true;
}
CreatureAI* GetAI(Creature* creature) const OVERRIDE
{
return new npc_raliq_the_drunkAI(creature);
}
struct npc_raliq_the_drunkAI : public ScriptedAI
{
npc_raliq_the_drunkAI(Creature* creature) : ScriptedAI(creature)
{
m_uiNormFaction = creature->getFaction();
}
uint32 m_uiNormFaction;
uint32 Uppercut_Timer;
void Reset() OVERRIDE
{
Uppercut_Timer = 5000;
me->RestoreFaction();
}
void UpdateAI(uint32 diff) OVERRIDE
{
if (!UpdateVictim())
return;
if (Uppercut_Timer <= diff)
{
DoCastVictim(SPELL_UPPERCUT);
Uppercut_Timer = 15000;
} else Uppercut_Timer -= diff;
DoMeleeAttackIfReady();
}
};
};
/*######
# npc_salsalabim
######*/
enum Salsalabim
{
// Factions
FACTION_HOSTILE_SA = 90,
FACTION_FRIENDLY_SA = 35,
// Quests
QUEST_10004 = 10004,
// Spells
SPELL_MAGNETIC_PULL = 31705
};
class npc_salsalabim : public CreatureScript
{
public:
npc_salsalabim() : CreatureScript("npc_salsalabim") { }
bool OnGossipHello(Player* player, Creature* creature) OVERRIDE
{
if (player->GetQuestStatus(QUEST_10004) == QUEST_STATUS_INCOMPLETE)
{
creature->setFaction(FACTION_HOSTILE_SA);
creature->AI()->AttackStart(player);
}
else
{
if (creature->IsQuestGiver())
player->PrepareQuestMenu(creature->GetGUID());
player->SEND_GOSSIP_MENU(player->GetGossipTextId(creature), creature->GetGUID());
}
return true;
}
CreatureAI* GetAI(Creature* creature) const OVERRIDE
{
return new npc_salsalabimAI(creature);
}
struct npc_salsalabimAI : public ScriptedAI
{
npc_salsalabimAI(Creature* creature) : ScriptedAI(creature) { }
uint32 MagneticPull_Timer;
void Reset() OVERRIDE
{
MagneticPull_Timer = 15000;
me->RestoreFaction();
}
void DamageTaken(Unit* done_by, uint32 &damage) OVERRIDE
{
if (done_by->GetTypeId() == TypeID::TYPEID_PLAYER && me->HealthBelowPctDamaged(20, damage))
{
done_by->ToPlayer()->GroupEventHappens(QUEST_10004, me);
damage = 0;
EnterEvadeMode();
}
}
void UpdateAI(uint32 diff) OVERRIDE
{
if (!UpdateVictim())
return;
if (MagneticPull_Timer <= diff)
{
DoCastVictim(SPELL_MAGNETIC_PULL);
MagneticPull_Timer = 15000;
} else MagneticPull_Timer -= diff;
DoMeleeAttackIfReady();
}
};
};
/*
##################################################
Shattrath City Flask Vendors provides flasks to people exalted with 3 fActions:
Haldor the Compulsive
Arcanist Xorith
Both sell special flasks for use in Outlands 25man raids only,
purchasable for one Mark of Illidari each
Purchase requires exalted reputation with Scryers/Aldor, Cenarion Expedition and The Sha'tar
##################################################
*/
class npc_shattrathflaskvendors : public CreatureScript
{
public:
npc_shattrathflaskvendors() : CreatureScript("npc_shattrathflaskvendors") { }
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) OVERRIDE
{
player->PlayerTalkClass->ClearMenus();
if (action == GOSSIP_ACTION_TRADE)
player->GetSession()->SendListInventory(creature->GetGUID());
return true;
}
bool OnGossipHello(Player* player, Creature* creature) OVERRIDE
{
if (creature->GetEntry() == 23484)
{
// Aldor vendor
if (creature->IsVendor() && (player->GetReputationRank(932) == REP_EXALTED) && (player->GetReputationRank(935) == REP_EXALTED) && (player->GetReputationRank(942) == REP_EXALTED))
{
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
player->SEND_GOSSIP_MENU(11085, creature->GetGUID());
}
else
{
player->SEND_GOSSIP_MENU(11083, creature->GetGUID());
}
}
if (creature->GetEntry() == 23483)
{
// Scryers vendor
if (creature->IsVendor() && (player->GetReputationRank(934) == REP_EXALTED) && (player->GetReputationRank(935) == REP_EXALTED) && (player->GetReputationRank(942) == REP_EXALTED))
{
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
player->SEND_GOSSIP_MENU(11085, creature->GetGUID());
}
else
{
player->SEND_GOSSIP_MENU(11084, creature->GetGUID());
}
}
return true;
}
};
/*######
# npc_zephyr
######*/
#define GOSSIP_HZ "Take me to the Caverns of Time."
class npc_zephyr : public CreatureScript
{
public:
npc_zephyr() : CreatureScript("npc_zephyr") { }
bool OnGossipSelect(Player* player, Creature* /*creature*/, uint32 /*sender*/, uint32 action) OVERRIDE
{
player->PlayerTalkClass->ClearMenus();
if (action == GOSSIP_ACTION_INFO_DEF+1)
player->CastSpell(player, 37778, false);
return true;
}
bool OnGossipHello(Player* player, Creature* creature) OVERRIDE
{
if (player->GetReputationRank(989) >= REP_REVERED)
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_HZ, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
player->SEND_GOSSIP_MENU(player->GetGossipTextId(creature), creature->GetGUID());
return true;
}
};
/*######
# npc_kservant
######*/
enum KServant
{
SAY1 = 0,
WHISP1 = 1,
WHISP2 = 2,
WHISP3 = 3,
WHISP4 = 4,
WHISP5 = 5,
WHISP6 = 6,
WHISP7 = 7,
WHISP8 = 8,
WHISP9 = 9,
WHISP10 = 10,
WHISP11 = 11,
WHISP12 = 12,
WHISP13 = 13,
WHISP14 = 14,
WHISP15 = 15,
WHISP16 = 16,
WHISP17 = 17,
WHISP18 = 18,
WHISP19 = 19,
WHISP20 = 20,
WHISP21 = 21
};
class npc_kservant : public CreatureScript
{
public:
npc_kservant() : CreatureScript("npc_kservant") { }
CreatureAI* GetAI(Creature* creature) const OVERRIDE
{
return new npc_kservantAI(creature);
}
struct npc_kservantAI : public npc_escortAI
{
public:
npc_kservantAI(Creature* creature) : npc_escortAI(creature) { }
void WaypointReached(uint32 waypointId) OVERRIDE
{
Player* player = GetPlayerForEscort();
if (!player)
return;
switch (waypointId)
{
case 0:
Talk(SAY1, player);
break;
case 4:
Talk(WHISP1, player);
break;
case 6:
Talk(WHISP2, player);
break;
case 7:
Talk(WHISP3, player);
break;
case 8:
Talk(WHISP4, player);
break;
case 17:
Talk(WHISP5, player);
break;
case 18:
Talk(WHISP6, player);
break;
case 19:
Talk(WHISP7, player);
break;
case 33:
Talk(WHISP8, player);
break;
case 34:
Talk(WHISP9, player);
break;
case 35:
Talk(WHISP10, player);
break;
case 36:
Talk(WHISP11, player);
break;
case 43:
Talk(WHISP12, player);
break;
case 44:
Talk(WHISP13, player);
break;
case 49:
Talk(WHISP14, player);
break;
case 50:
Talk(WHISP15, player);
break;
case 51:
Talk(WHISP16, player);
break;
case 52:
Talk(WHISP17, player);
break;
case 53:
Talk(WHISP18, player);
break;
case 54:
Talk(WHISP19, player);
break;
case 55:
Talk(WHISP20, player);
break;
case 56:
Talk(WHISP21, player);
player->GroupEventHappens(10211, me);
break;
}
}
void MoveInLineOfSight(Unit* who) OVERRIDE
{
if (HasEscortState(STATE_ESCORT_ESCORTING))
return;
Player* player = who->ToPlayer();
if (player && player->GetQuestStatus(10211) == QUEST_STATUS_INCOMPLETE)
{
float Radius = 10.0f;
if (me->IsWithinDistInMap(who, Radius))
{
Start(false, false, who->GetGUID());
}
}
}
void Reset() OVERRIDE { }
};
};
/*######
# npc_ishanah
######*/
#define ISANAH_GOSSIP_1 "Who are the Sha'tar?"
#define ISANAH_GOSSIP_2 "Isn't Shattrath a draenei city? Why do you allow others here?"
class npc_ishanah : public CreatureScript
{
public:
npc_ishanah() : CreatureScript("npc_ishanah") { }
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) OVERRIDE
{
player->PlayerTalkClass->ClearMenus();
if (action == GOSSIP_ACTION_INFO_DEF+1)
player->SEND_GOSSIP_MENU(9458, creature->GetGUID());
else if (action == GOSSIP_ACTION_INFO_DEF+2)
player->SEND_GOSSIP_MENU(9459, creature->GetGUID());
return true;
}
bool OnGossipHello(Player* player, Creature* creature) OVERRIDE
{
if (creature->IsQuestGiver())
player->PrepareQuestMenu(creature->GetGUID());
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, ISANAH_GOSSIP_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, ISANAH_GOSSIP_2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+2);
player->SEND_GOSSIP_MENU(player->GetGossipTextId(creature), creature->GetGUID());
return true;
}
};
/*######
# npc_khadgar
######*/
#define KHADGAR_GOSSIP_1 "I've heard your name spoken only in whispers, mage. Who are you?"
#define KHADGAR_GOSSIP_2 "Go on, please."
#define KHADGAR_GOSSIP_3 "I see." //6th too this
#define KHADGAR_GOSSIP_4 "What did you do then?"
#define KHADGAR_GOSSIP_5 "What happened next?"
#define KHADGAR_GOSSIP_7 "There was something else I wanted to ask you."
class npc_khadgar : public CreatureScript
{
public:
npc_khadgar() : CreatureScript("npc_khadgar") { }
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) OVERRIDE
{
player->PlayerTalkClass->ClearMenus();
switch (action)
{
case GOSSIP_ACTION_INFO_DEF+1:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, KHADGAR_GOSSIP_2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+2);
player->SEND_GOSSIP_MENU(9876, creature->GetGUID());
break;
case GOSSIP_ACTION_INFO_DEF+2:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, KHADGAR_GOSSIP_3, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+3);
player->SEND_GOSSIP_MENU(9877, creature->GetGUID());
break;
case GOSSIP_ACTION_INFO_DEF+3:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, KHADGAR_GOSSIP_4, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+4);
player->SEND_GOSSIP_MENU(9878, creature->GetGUID());
break;
case GOSSIP_ACTION_INFO_DEF+4:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, KHADGAR_GOSSIP_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+5);
player->SEND_GOSSIP_MENU(9879, creature->GetGUID());
break;
case GOSSIP_ACTION_INFO_DEF+5:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, KHADGAR_GOSSIP_3, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+6);
player->SEND_GOSSIP_MENU(9880, creature->GetGUID());
break;
case GOSSIP_ACTION_INFO_DEF+6:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, KHADGAR_GOSSIP_7, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+7);
player->SEND_GOSSIP_MENU(9881, creature->GetGUID());
break;
case GOSSIP_ACTION_INFO_DEF+7:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, KHADGAR_GOSSIP_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
player->SEND_GOSSIP_MENU(9243, creature->GetGUID());
break;
}
return true;
}
bool OnGossipHello(Player* player, Creature* creature) OVERRIDE
{
if (creature->IsQuestGiver())
player->PrepareQuestMenu(creature->GetGUID());
if (player->GetQuestStatus(10211) != QUEST_STATUS_INCOMPLETE)
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, KHADGAR_GOSSIP_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
player->SEND_GOSSIP_MENU(9243, creature->GetGUID());
return true;
}
};
void AddSC_shattrath_city()
{
new npc_raliq_the_drunk();
new npc_salsalabim();
new npc_shattrathflaskvendors();
new npc_zephyr();
new npc_kservant();
new npc_ishanah();
new npc_khadgar();
}
| Java |
<?php
/**
* Template Name: Sidebar Left Template
*
* @package WordPress
* @subpackage Invictus
* @since Invictus 1.0
*/
get_header();
?>
<div id="single-page" class="clearfix left-sidebar">
<div id="primary">
<div id="content" role="main">
<?php the_post(); ?>
<?php get_template_part( 'content', 'page' ); ?>
</div><!-- #content -->
</div><!-- #primary -->
<div id="sidebar">
<?php /* Widgetised Area */ if ( !function_exists( 'dynamic_sidebar' ) || !dynamic_sidebar('sidebar-main') ) ?>
</div>
</div>
<?php get_footer(); ?>
| Java |
//
// CRTDispatchConnection.cpp
// dyncRTConnector
//
// Created by hp on 12/8/15.
// Copyright (c) 2015 hp. All rights reserved.
//
#include "CRTDispatchConnection.h"
#include "CRTConnManager.h"
#include "CRTConnection.h"
#include "CRTConnectionTcp.h"
#include "rtklog.h"
void CRTDispatchConnection::DispatchMsg(const std::string& uid, pms::RelayMsg& r_msg)
{
//find connector
CRTConnManager::ConnectionInfo* pci = CRTConnManager::Instance().findConnectionInfoById(uid);
if (!pci) {
LE("CRTDispatchConnection::DispatchMsg not find user:%s connection\n", uid.c_str());
LI("CRTDispatchConnection::DispatchMsg handle_cmd:%s, handle_mtype:%s, handle_data:%s\n", r_msg.handle_cmd().c_str(), r_msg.handle_mtype().c_str(), r_msg.handle_data().c_str());
// not set push in this msg
if (r_msg.handle_cmd().length()==0 \
|| r_msg.handle_cmd().compare("push")!=0 \
|| r_msg.handle_data().length()==0 \
|| r_msg.handle_data().compare("1")!=0)
{
LE("CRTDispatchConnection::DispatchMsg this type of message is no need to push, so return\n");
return;
}
LI("CRTDispatchConnection::DispatchMsg userid:%s, r_msg.cont_module:%d\n\n", uid.c_str(), r_msg.cont_module());
// user set not accept push
// user set mute notification
if (!CRTConnManager::Instance().CouldPush(uid, r_msg.cont_module()))
{
LE("CRTDispatchConnection::DispatchMsg user set do not accept push or mute notify, so return\n");
return;
}
// get redis setting enablepush
// find pusher module and sent to pusher
CRTConnManager::ModuleInfo* pmodule = CRTConnManager::Instance().findModuleInfo("", pms::ETransferModule::MPUSHER);
if (pmodule && pmodule->pModule && pmodule->pModule->IsLiveSession()) {
pms::TransferMsg t_msg;
//r_msg.set_svr_cmds(cmd);
r_msg.set_tr_module(pms::ETransferModule::MCONNECTOR);
r_msg.set_connector(CRTConnManager::Instance().ConnectorId());
t_msg.set_type(pms::ETransferType::TQUEUE);
t_msg.set_content(r_msg.SerializeAsString());
std::string s = t_msg.SerializeAsString();
pmodule->pModule->SendTransferData(s.c_str(), (int)s.length());
LI("CRTDispatchConnection::DispatchMsg has send push msg to pusher, module type:%d, module id:%s!!!\n\n", pmodule->othModuleType, pmodule->othModuleId.c_str());
} else {
LE("CRTDispatchConnection::DispatchMsg module pusher is not liveeeeeeeeeeee!!!\n");
}
return;
} else { //!pci
if (pci->_pConn && pci->_pConn->IsLiveSession()) {
if (pci->_connType == pms::EConnType::THTTP) {
CRTConnection *c = dynamic_cast<CRTConnection*>(pci->_pConn);
if (c) {
c->SendDispatch(uid, r_msg.content());
}
} else if (pci->_connType == pms::EConnType::TTCP) {
CRTConnectionTcp *ct = dynamic_cast<CRTConnectionTcp*>(pci->_pConn);
if (ct) {
ct->SendDispatch(uid, r_msg.content());
}
}
}
}
}
| Java |
'use strict';
/*@ngInject*/
function repoItemClassifierFilter() {
return function(node) {
if (node.type) {
return 'uib-repository__item--movable';
} else {
return 'uib-repository__group';
}
};
}
module.exports = repoItemClassifierFilter;
| Java |
class ActorEffectActorPen < ActorEffect
title 'Actor Pen'
description 'Uses chosen actor as a brush tip, rendering it multiple times per frame to smoothly follow a chosen X,Y point.'
hint 'This effect is primarily intended for use with the Canvas actor.'
categories :canvas
setting 'actor', :actor
setting 'offset_x', :float, :default => 0.0..1.0
setting 'offset_y', :float, :default => 0.0..1.0
setting 'period', :float, :default => 0.01..1.0
setting 'scale', :float, :default => 1.0..2.0
setting 'alpha', :float, :default => 1.0..1.0, :range => 0.0..1.0
setting 'maximum_per_frame', :integer, :range => 1..1000, :default => 50..1000
def render
return yield if scale == 0.0
actor.one { |a|
parent_user_object.using {
with_alpha(alpha) {
prev_x = offset_x_setting.last_value
prev_y = offset_y_setting.last_value
delta_x = offset_x - prev_x
delta_y = offset_y - prev_y
prev_scale = scale_setting.last_value
delta_scale = (scale - prev_scale)
distance = Math.sqrt(delta_x*delta_x + delta_y*delta_y)
count = ((distance / scale) / period).floor
count = maximum_per_frame if count > maximum_per_frame
if count < 2
with_translation(offset_x, offset_y) {
with_scale(scale) {
a.render!
}
}
else
step_x = delta_x / count
step_y = delta_y / count
step_scale = delta_scale / count
beat_delta = $env[:beat_delta]
for i in 1..count
progress = (i.to_f / count)
with_beat_shift(-beat_delta * (1.0 - progress)) {
with_translation(prev_x + step_x*i, prev_y + step_y*i) {
with_scale(prev_scale + step_scale*i) {
a.render!
}
}
}
end
end
}
}
}
yield
end
end
| Java |
//
// XRLoginView.h
// XyralityTest
//
// Created by lava on 12/19/15.
//
//
#import <UIKit/UIKit.h>
@interface XRLoginView : UIView
@property (weak, nonatomic) IBOutlet UIView *credentialsView;
@property (weak, nonatomic) IBOutlet UILabel *loginLabel;
@property (weak, nonatomic) IBOutlet UITextField *loginTextField;
@property (weak, nonatomic) IBOutlet UILabel *passwordLabel;
@property (weak, nonatomic) IBOutlet UITextField *passworldTextField;
@property (weak, nonatomic) IBOutlet UIButton *showMyWorldsButton;
@property (weak, nonatomic) IBOutlet UIActivityIndicatorView *activtyIndicator;
- (void)startProgressAnimation;
- (void)stopProgressAnimation;
@end
| Java |
<?php // (C) Copyright Bobbing Wide 2012, 2017
/**
* Determine the reference_type from PHP tokens
*
* Attempt to determine what sort of API this is using token_get_all()
*
* @param string $string - the "api" name
* @return string - the reference type determined from token_name()
*
*/
function oikai_determine_from_tokens( $string ) {
$reference_type = null;
$tokens = token_get_all( "<?php $string" );
$token = array_shift( $tokens );
while ( $token ) {
$token = array_shift( $tokens );
if ( is_array( $token ) ) {
//print_r( $token );
$token_name = token_name( $token[0] );
//$reference_type = _oikai_determine_reference_type( $
$reference_type = $token_name;
$token = null;
}
}
return( $reference_type );
}
/**
* See if this is a constant name
*
* @param string $string - could be ABSPATH or WPINC or something
*
*
*/
function oikai_check_constants( $string ) {
$constants = get_defined_constants( false );
//$reference_type = oikai_query_function_type
$constant = bw_array_get( $constants, $string, null );
if ( $constant ) {
$reference_type = "constant";
} else {
$reference_type = "T_STRING";
}
return( $reference_type );
}
/**
*
*/
function oikai_check_class_method_or_function( $string ) {
$reference_type = "T_STRING";
$class = oikai_get_class( $string, null );
if ( $class ) {
$func = oikai_get_func( $string, $class );
if ( $func ) {
$reference_type = "method";
} else {
$reference_type = "class";
}
} else {
$reference_type = "function";
}
return( $reference_type );
}
/**
* Determine the reference type for a string
*
* @param string $string - the passed string literal
* @return string - the determined reference type
*
* Value | Meaning
* -------- | -------
* internal | This is a PHP function
* user | This is a currently active application function
* T_STRING | We couldn't decide
* constant | It's a defined constant name ( currently active )
* T_ other | It's a PHP token such as T_REQUIRE, T_REQUIRE_ONCE, etc
* class | It's a class
* function | It's a function - but it's not active otherwise we'd have received "user" or "internal"
* method | It's a method ( with class name )
* null | Not expected at the end of this processing
*/
function oikai_determine_reference_type( $string ) {
$reference_type = oikai_determine_function_type( $string );
if ( !$reference_type ) {
$reference_type = oikai_determine_from_tokens( $string );
}
if ( $reference_type == "T_STRING" ) {
$reference_type = oikai_check_constants( $string );
}
if ( $reference_type == "T_STRING" ) {
$reference_type = oikai_check_class_method_or_function( $string );
}
//p( "$string:$reference_type" );
return( $reference_type );
}
/**
* Handle a link to a "user" function
*
*/
function oikai_handle_reference_type_user( $api, $reference_type ) {
$posts = oikai_get_oik_apis_byname( $api );
bw_trace2( $posts );
if ( $posts ) {
oikapi_simple_link( $api, $posts );
} else {
e( oikai_link_to_wordpress( $api ) );
}
e( "()" );
}
/**
* Handle a link to an "internal" PHP function
*
* This includes T_xxx values we don't yet cater for
*
*
*/
function oikai_handle_reference_type_internal( $api, $reference_type ) {
e( oikai_link_to_php( $api ));
e( "()" );
}
/**
* Handle a link to a "function"
*/
function oikai_handle_reference_type_function( $api, $reference_type ) {
oikai_handle_reference_type_user( $api, $reference_type );
}
/**
* Handle a link to a "class"
*
*/
function oikai_handle_reference_type_class( $api, $reference_type ) {
$posts = oikai_get_oik_class_byname( $api );
bw_trace2( $posts );
if ( $posts ) {
oikapi_simple_link( $api, $posts );
} else {
e( oikai_link_to_wordpress( $api ) );
}
}
/**
* Produce a link to the API based on the reference_type
*
* @param string $api - the API name
* @param string $reference_type - the determined reference type
*
*/
function oikai_handle_reference_type( $api, $reference_type ) {
$funcname = bw_funcname( __FUNCTION__, $reference_type );
//e( $funcname );
if ( $funcname != __FUNCTION__ ) {
if ( is_callable( $funcname ) ) {
call_user_func( $funcname, $api, $reference_type );
} else {
fob();
oikai_handle_reference_type_internal( $api, $reference_type );
}
} else {
oikai_handle_reference_type_internal( $api, $reference_type );
}
}
/**
* Simplify the API name
*
* Sometimes we write an API as apiname()
* If we wrap this in the API shortcode we should be able to cater for the extraneous ()'s
*
* There could be other things we could also do... such as sanitization
*
* @param string $api - the given API name
* @return string - the simplified API name
*
*/
function oikai_simplify_apiname( $api ) {
$api = str_replace( "()", "", $api );
return( $api );
}
/**
* Implement [api] shortcode to produce simple links to an API
*
* If there's just one API it's shown as "api()".
* If more than one then they're comma separated, but NOT in an HTML list "api(), api2()"
* Links are created to PHP, the local site or the 'preferred' WordPress reference site.
*
* @param array $atts - shortcode parameters
* @param string $content - content
* @param string $tag - the shortcode tag
* @return string - generated HTML
*
*/
function oikai_api( $atts=null, $content=null, $tag=null ) {
oiksc_autoload();
$apis = bw_array_get_from( $atts, "api,0", null );
if ( $apis ) {
$apia = bw_as_array( $apis );
oik_require( "shortcodes/oik-apilink.php", "oik-shortcodes" );
oik_require( "shortcodes/oik-api-importer.php", "oik-shortcodes" );
$count = 0;
foreach ( $apia as $key => $api ) {
$api = oikai_simplify_apiname( $api );
if ( $count ) {
e( "," );
e( " " );
}
$count++;
$type = oikai_determine_reference_type( $api );
oikai_handle_reference_type( $api, $type );
}
} else {
oik_require( "shortcodes/oik-api-status.php", "oik-shortcodes" );
oikai_api_status( $atts );
}
return( bw_ret() );
}
/**
* OK, but we also want to link to PHP stuff
* So we need to be able to call that function
*
*/
function oikapi_simple_link( $api, $posts ) {
if ( $posts ) {
$post = bw_array_get( $posts, 0, null );
} else {
$post = null;
}
if ( $post ) {
alink( "bw_api", get_permalink( $post ), $api, $post->title );
} else {
e( $api );
}
}
/**
* Help hook for [api] shortcode
*/
function api__help( $shortcode="api" ) {
return( "Simple API link" );
}
/**
* Syntax hook for [api] shortcode
*/
function api__syntax( $shortcode="api" ) {
$syntax = array( "api|0" => bw_skv( null, "<i>api</i>", "API name" )
);
return( $syntax );
}
/**
* Example hook for [api] shortcode
*/
function api__example( $shortcode="api" ) {
oik_require( "includes/oik-sc-help.php" );
$text = "Links to different APIs: PHP,locally documented,WordPress reference" ;
$example = "require,oik_require,hello_dolly";
bw_invoke_shortcode( $shortcode, $example, $text );
}
| Java |
;; *******************************************************************
;; $Id: test.asm,v 1.1 2006-06-05 02:12:19 arniml Exp $
;;
;; Checks interrupt on a sequence of "transfer of control"
;; instructions.
;;
;; the cpu type is defined on asl's command line
include "int_macros.inc"
org 0x00
clra
int_flag_clear
lei 0x02
jp int_mark
org 0x030
int_mark:
nop
nop
int_instr:
jmp +
+ jp +
+ jsrp jsrp_target
jsr jsrp_target
lqid
nop
ret_instr:
jmp +
org 0x040
+ int_flag_check
jmp pass
org 0x080
jsrp_target:
ret
;; *******************************************************************
;; Interrupt routine
;;
org 0x0fd
jmp fail
int_routine:
nop
save_a_m_c
int_flag_set
check_sa ret_instr
restore_c_m_a
ret
org 0x200
include "int_pass_fail.asm"
| Java |
<?php
/**
* Custom Article Page Type
*
* @package tub
*/
/*
* Register an article post type.
*/
add_action( 'init', 'tub_articles_init' );
function tub_articles_init() {
$labels = array(
'name' => _x( 'Articles', 'post type general name', 'tub' ),
'singular_name' => _x( 'Article', 'post type singular name', 'tub' ),
'menu_name' => _x( 'Articles', 'admin menu', 'tub' ),
'name_admin_bar' => _x( 'Article', 'add new on admin bar', 'tub' ),
'add_new' => _x( 'Add New', 'article', 'tub' ),
'add_new_item' => __( 'Add New Article', 'tub' ),
'new_item' => __( 'New Article', 'tub' ),
'edit_item' => __( 'Edit Article', 'tub' ),
'view_item' => __( 'View Article', 'tub' ),
'all_items' => __( 'All Articles', 'tub' ),
'search_items' => __( 'Search Articles', 'tub' ),
'parent_item_colon' => __( 'Parent Articles:', 'tub' ),
'not_found' => __( 'No articles found.', 'tub' ),
'not_found_in_trash' => __( 'No articles found in Trash.', 'tub' )
);
$args = array(
'labels' => $labels,
'public' => true,
'publicly_queryable' => true,
'show_ui' => true,
'show_in_nav_menus' => true,
'show_in_menu' => true,
'query_var' => true,
'rewrite' => array( 'slug' => 'article' ),
'capability_type' => 'page',
'hierarchical' => true,
'menu_position' => 20,
'menu_icon' => 'dashicons-format-aside',
'supports' => array( 'title', 'editor', 'author', 'thumbnail', 'excerpt', 'revisions', 'page-attributes' )
);
register_post_type( 'article', $args );
}
/**
* Change Title Placeholder Text
*/
function tub_change_article_title( $title ){
$screen = get_current_screen();
if ( 'article' == $screen->post_type ){
$title = 'Enter menu label here';
}
return $title;
}
add_filter( 'enter_title_here', 'tub_change_article_title' );
/**
* Add a page title meta box
*/
// Add box
function tub_article_add_title(){
add_meta_box(
'article_title_meta',
__('Page Title'),
'tub_article_title_content',
'article',
'normal',
'high'
);
}
add_action("add_meta_boxes", "tub_article_add_title");
// Print box content
function tub_article_title_content( $post ){
// Add an nonce field so we can check for it later.
wp_nonce_field( 'tub_article_meta_box', 'tub_article_meta_box_nonce' );
$article_title = get_post_meta( $post->ID, 'tub_article_title', true );
echo '<input type="text" name="tub_article_title" value="' . esc_attr( $article_title ) . '" style="width: 100%;margin-top: 6px;" placeholder="Enter title here" />';
}
/**
* Save Data
*/
function tub_article_title_save( $post_id ) {
/*
* We need to verify this came from our screen and with proper authorization,
* because the save_post action can be triggered at other times.
*/
// Check if our nonce is set.
if ( ! isset( $_POST['tub_article_meta_box_nonce'] ) ) {
return;
}
// Verify that the nonce is valid.
if ( ! wp_verify_nonce( $_POST['tub_article_meta_box_nonce'], 'tub_article_meta_box' ) ) {
return;
}
// If this is an autosave, our form has not been submitted, so we don't want to do anything.
if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE ) {
return;
}
// Check the user's permissions.
if ( isset( $_POST['post_type'] ) && 'page' == $_POST['post_type'] ) {
if ( ! current_user_can( 'edit_page', $post_id ) ) {
return;
}
} else {
if ( ! current_user_can( 'edit_post', $post_id ) ) {
return;
}
}
/* OK, it's safe for us to save the data now. */
// Save testimonial date data if the field isset
if ( isset( $_POST['tub_article_title'] ) ) {
$tub_article_title_data = sanitize_text_field( $_POST['tub_article_title'] );
update_post_meta( $post_id, 'tub_article_title', $tub_article_title_data );
}
return;
}
add_action( 'save_post', 'tub_article_title_save' );
| Java |
/* Copyright Statement:
*
* This software/firmware and related documentation ("MediaTek Software") are
* protected under relevant copyright laws. The information contained herein
* is confidential and proprietary to MediaTek Inc. and/or its licensors.
* Without the prior written permission of MediaTek inc. and/or its licensors,
* any reproduction, modification, use or disclosure of MediaTek Software,
* and information contained herein, in whole or in part, shall be strictly prohibited.
*
* MediaTek Inc. (C) 2010. All rights reserved.
*
* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
* THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
* CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
* SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
* CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
* The following software/firmware and/or related documentation ("MediaTek Software")
* have been modified by MediaTek Inc. All revisions are subject to any receiver's
* applicable license agreements with MediaTek Inc.
*/
/*
* Copyright (C) 2007-2009 Freescale Semiconductor, Inc.
* Copyright (C) 2008-2009 MontaVista Software, Inc.
*
* Authors: Tony Li <tony.li@freescale.com>
* Anton Vorontsov <avorontsov@ru.mvista.com>
*
* 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-1307 USA
*/
#include <common.h>
#include <pci.h>
#include <mpc83xx.h>
#include <asm/io.h>
DECLARE_GLOBAL_DATA_PTR;
#define PCIE_MAX_BUSES 2
#ifdef CONFIG_83XX_GENERIC_PCIE_REGISTER_HOSES
static int mpc83xx_pcie_remap_cfg(struct pci_controller *hose, pci_dev_t dev)
{
int bus = PCI_BUS(dev) - hose->first_busno;
immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
pex83xx_t *pex = &immr->pciexp[bus];
struct pex_outbound_window *out_win = &pex->bridge.pex_outbound_win[0];
u8 devfn = PCI_DEV(dev) << 3 | PCI_FUNC(dev);
u32 dev_base = bus << 24 | devfn << 16;
if (hose->indirect_type == INDIRECT_TYPE_NO_PCIE_LINK)
return -1;
/*
* Workaround for the HW bug: for Type 0 configure transactions the
* PCI-E controller does not check the device number bits and just
* assumes that the device number bits are 0.
*/
if (devfn & 0xf8)
return -1;
out_le32(&out_win->tarl, dev_base);
return 0;
}
#define cfg_read(val, addr, type, op) \
do { *val = op((type)(addr)); } while (0)
#define cfg_write(val, addr, type, op) \
do { op((type *)(addr), (val)); } while (0)
#define cfg_read_err(val) do { *val = -1; } while (0)
#define cfg_write_err(val) do { } while (0)
#define PCIE_OP(rw, size, type, op) \
static int pcie_##rw##_config_##size(struct pci_controller *hose, \
pci_dev_t dev, int offset, \
type val) \
{ \
int ret; \
\
ret = mpc83xx_pcie_remap_cfg(hose, dev); \
if (ret) { \
cfg_##rw##_err(val); \
return ret; \
} \
cfg_##rw(val, (void *)hose->cfg_addr + offset, type, op); \
return 0; \
}
PCIE_OP(read, byte, u8 *, in_8)
PCIE_OP(read, word, u16 *, in_le16)
PCIE_OP(read, dword, u32 *, in_le32)
PCIE_OP(write, byte, u8, out_8)
PCIE_OP(write, word, u16, out_le16)
PCIE_OP(write, dword, u32, out_le32)
static void mpc83xx_pcie_register_hose(int bus, struct pci_region *reg,
u8 link)
{
extern void disable_addr_trans(void); /* start.S */
static struct pci_controller pcie_hose[PCIE_MAX_BUSES];
struct pci_controller *hose = &pcie_hose[bus];
int i;
/*
* There are no spare BATs to remap all PCI-E windows for U-Boot, so
* disable translations. In general, this is not great solution, and
* that's why we don't register PCI-E hoses by default.
*/
disable_addr_trans();
for (i = 0; i < 2; i++, reg++) {
if (reg->size == 0)
break;
hose->regions[i] = *reg;
hose->region_count++;
}
i = hose->region_count++;
hose->regions[i].bus_start = 0;
hose->regions[i].phys_start = 0;
hose->regions[i].size = gd->ram_size;
hose->regions[i].flags = PCI_REGION_MEM | PCI_REGION_SYS_MEMORY;
i = hose->region_count++;
hose->regions[i].bus_start = CONFIG_SYS_IMMR;
hose->regions[i].phys_start = CONFIG_SYS_IMMR;
hose->regions[i].size = 0x100000;
hose->regions[i].flags = PCI_REGION_MEM | PCI_REGION_SYS_MEMORY;
hose->first_busno = pci_last_busno() + 1;
hose->last_busno = 0xff;
if (bus == 0)
hose->cfg_addr = (unsigned int *)CONFIG_SYS_PCIE1_CFG_BASE;
else
hose->cfg_addr = (unsigned int *)CONFIG_SYS_PCIE2_CFG_BASE;
pci_set_ops(hose,
pcie_read_config_byte,
pcie_read_config_word,
pcie_read_config_dword,
pcie_write_config_byte,
pcie_write_config_word,
pcie_write_config_dword);
if (!link)
hose->indirect_type = INDIRECT_TYPE_NO_PCIE_LINK;
pci_register_hose(hose);
#ifdef CONFIG_PCI_SCAN_SHOW
printf("PCI: Bus Dev VenId DevId Class Int\n");
#endif
/*
* Hose scan.
*/
hose->last_busno = pci_hose_scan(hose);
}
#else
static void mpc83xx_pcie_register_hose(int bus, struct pci_region *reg,
u8 link) {}
#endif /* CONFIG_83XX_GENERIC_PCIE_REGISTER_HOSES */
static void mpc83xx_pcie_init_bus(int bus, struct pci_region *reg)
{
immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
pex83xx_t *pex = &immr->pciexp[bus];
struct pex_outbound_window *out_win;
struct pex_inbound_window *in_win;
void *hose_cfg_base;
unsigned int ram_sz;
unsigned int barl;
unsigned int tar;
u16 reg16;
int i;
/* Enable pex csb bridge inbound & outbound transactions */
out_le32(&pex->bridge.pex_csb_ctrl,
in_le32(&pex->bridge.pex_csb_ctrl) | PEX_CSB_CTRL_OBPIOE |
PEX_CSB_CTRL_IBPIOE);
/* Enable bridge outbound */
out_le32(&pex->bridge.pex_csb_obctrl, PEX_CSB_OBCTRL_PIOE |
PEX_CSB_OBCTRL_MEMWE | PEX_CSB_OBCTRL_IOWE |
PEX_CSB_OBCTRL_CFGWE);
out_win = &pex->bridge.pex_outbound_win[0];
if (bus) {
out_le32(&out_win->ar, PEX_OWAR_EN | PEX_OWAR_TYPE_CFG |
CONFIG_SYS_PCIE2_CFG_SIZE);
out_le32(&out_win->bar, CONFIG_SYS_PCIE2_CFG_BASE);
} else {
out_le32(&out_win->ar, PEX_OWAR_EN | PEX_OWAR_TYPE_CFG |
CONFIG_SYS_PCIE1_CFG_SIZE);
out_le32(&out_win->bar, CONFIG_SYS_PCIE1_CFG_BASE);
}
out_le32(&out_win->tarl, 0);
out_le32(&out_win->tarh, 0);
for (i = 0; i < 2; i++, reg++) {
u32 ar;
if (reg->size == 0)
break;
out_win = &pex->bridge.pex_outbound_win[i + 1];
out_le32(&out_win->bar, reg->phys_start);
out_le32(&out_win->tarl, reg->bus_start);
out_le32(&out_win->tarh, 0);
ar = PEX_OWAR_EN | (reg->size & PEX_OWAR_SIZE);
if (reg->flags & PCI_REGION_IO)
ar |= PEX_OWAR_TYPE_IO;
else
ar |= PEX_OWAR_TYPE_MEM;
out_le32(&out_win->ar, ar);
}
out_le32(&pex->bridge.pex_csb_ibctrl, PEX_CSB_IBCTRL_PIOE);
ram_sz = gd->ram_size;
barl = 0;
tar = 0;
i = 0;
while (ram_sz > 0) {
in_win = &pex->bridge.pex_inbound_win[i];
out_le32(&in_win->barl, barl);
out_le32(&in_win->barh, 0x0);
out_le32(&in_win->tar, tar);
if (ram_sz >= 0x10000000) {
/* The maxium windows size is 256M */
out_le32(&in_win->ar, PEX_IWAR_EN | PEX_IWAR_NSOV |
PEX_IWAR_TYPE_PF | 0x0FFFF000);
barl += 0x10000000;
tar += 0x10000000;
ram_sz -= 0x10000000;
} else {
/* The UM is not clear here.
* So, round up to even Mb boundary */
ram_sz = ram_sz >> (20 +
((ram_sz & 0xFFFFF) ? 1 : 0));
if (!(ram_sz % 2))
ram_sz -= 1;
out_le32(&in_win->ar, PEX_IWAR_EN | PEX_IWAR_NSOV |
PEX_IWAR_TYPE_PF | (ram_sz << 20) | 0xFF000);
ram_sz = 0;
}
i++;
}
in_win = &pex->bridge.pex_inbound_win[i];
out_le32(&in_win->barl, CONFIG_SYS_IMMR);
out_le32(&in_win->barh, 0);
out_le32(&in_win->tar, CONFIG_SYS_IMMR);
out_le32(&in_win->ar, PEX_IWAR_EN |
PEX_IWAR_TYPE_NO_PF | PEX_IWAR_SIZE_1M);
/* Enable the host virtual INTX interrupts */
out_le32(&pex->bridge.pex_int_axi_misc_enb,
in_le32(&pex->bridge.pex_int_axi_misc_enb) | 0x1E0);
/* Hose configure header is memory-mapped */
hose_cfg_base = (void *)pex;
get_clocks();
/* Configure the PCIE controller core clock ratio */
out_le32(hose_cfg_base + PEX_GCLK_RATIO,
(((bus ? gd->pciexp2_clk : gd->pciexp1_clk) / 1000000) * 16)
/ 333);
udelay(1000000);
/* Do Type 1 bridge configuration */
out_8(hose_cfg_base + PCI_PRIMARY_BUS, 0);
out_8(hose_cfg_base + PCI_SECONDARY_BUS, 1);
out_8(hose_cfg_base + PCI_SUBORDINATE_BUS, 255);
/*
* Write to Command register
*/
reg16 = in_le16(hose_cfg_base + PCI_COMMAND);
reg16 |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY | PCI_COMMAND_IO |
PCI_COMMAND_SERR | PCI_COMMAND_PARITY;
out_le16(hose_cfg_base + PCI_COMMAND, reg16);
/*
* Clear non-reserved bits in status register.
*/
out_le16(hose_cfg_base + PCI_STATUS, 0xffff);
out_8(hose_cfg_base + PCI_LATENCY_TIMER, 0x80);
out_8(hose_cfg_base + PCI_CACHE_LINE_SIZE, 0x08);
printf("PCIE%d: ", bus);
reg16 = in_le16(hose_cfg_base + PCI_LTSSM);
if (reg16 >= PCI_LTSSM_L0)
printf("link\n");
else
printf("No link\n");
mpc83xx_pcie_register_hose(bus, reg, reg16 >= PCI_LTSSM_L0);
}
/*
* The caller must have already set SCCR, SERDES and the PCIE_LAW BARs
* must have been set to cover all of the requested regions.
*/
void mpc83xx_pcie_init(int num_buses, struct pci_region **reg, int warmboot)
{
int i;
/*
* Release PCI RST Output signal.
* Power on to RST high must be at least 100 ms as per PCI spec.
* On warm boots only 1 ms is required.
*/
udelay(warmboot ? 1000 : 100000);
for (i = 0; i < num_buses; i++)
mpc83xx_pcie_init_bus(i, reg[i]);
}
| Java |
/* VARS
-------------------------------------------------------------- */
/* COLORS */
/* DARK GREY */
/* RED */
/* MIX-INS
-------------------------------------------------------------- */
.inline_block, #block-system-main-menu li span, #block-system-main-menu li a {
display: inline-block;
zoom: 1;
*display: inline; }
.clearfix, .link .image {
zoom: 1; }
.clearfix:before, .link .image:before, .clearfix:after, .link .image:after {
content: "\0020";
display: block;
height: 0;
overflow: hidden; }
.clearfix:after, .link .image:after {
clear: both; }
/* COMMON
-------------------------------------------------------------- */
.soon{
width: 300px;
height: 100px;
line-height: 100px;
font-size: 20px;
text-align: center;
background: #ea7d67;
position: absolute;
top: 50%;
left: 50%;
margin: -80px 0 0 -150px;
text-transform: uppercase;
}
html {
background: #f5f3e9; }
body {
font-family: "Lato", sans-serif;
font-weight: 300;
color: #444444;
font-size: 18px; }
a {
cursor: pointer;
transition: color .3s ease;
color: #444444;
color: #444444;
text-decoration: none; }
a:hover {
color: #ea7d67;
}
a:hover {
color: #ea7d67; }
p a{
color: #ea7d67;
}
p a:hover{
text-decoration: underline;
}
li a.active,
li.opened span.nolink {
color: #ea7d67; }
h1 {
font-weight: 100;
margin-bottom: 40px;
padding-bottom: 10px;
margin-bottom: 10px; }
h1.main-title {
text-align: center;
font-size: 60px;
font-style: italic;
font-weight: 100;
margin-bottom: 40px; }
h2.pane-title{
text-align: center;
font-weight: 100;
margin: 20px 0;
}
.node-type-post h1.main-title {
display: none; }
p {
letter-spacing: normal;
font-size: 14px;
line-height: 24px;
position: relative;
font-family: "Gilda Display", serif;}
ul, ul.menu, ul.menu li {
list-style: none;
text-align: inherit; }
.bull {
color: #dddddd;
padding: 0 10px; }
/* HEADER
-------------------------------------------------------------- */
#header {
position: fixed;
background-color: #ea7d67;
height: 40px;
line-height: 40px;
width: 100%;
z-index: 999; }
#header .bot {
width: 100%;
height: 35px;
top: 40px;
position: absolute;
background-color: rgba(245, 243, 233, 0.9); }
#header-inner {
float: right; }
#u-big, #d-big {
position: absolute;
z-index: 1000; }
#u-big {
top: 60px;
left: 50%;
margin-left: -620px; }
#d-big {
top: 80px;
left: 50%;
margin-left: -170px; }
#ud-sm {
position: absolute;
top: 0;
left: 0; }
#ud-sm .logo {
right: inherit;
margin: 0;
line-height: normal;
width: 180px;
top: 0;
left: 240px; }
#ud-sm .logo .slogan {
margin-top: 5px; }
#u-sm {
position: absolute;
top: 10px;
left: 20px; }
#d-sm {
position: absolute;
top: 20px;
left: 155px; }
.logo {
font-size: 16px;
position: absolute; }
.logo a {
cursor: pointer;
transition: color .3s ease;
color: #444444;
text-transform: uppercase; }
.logo a:hover {
color: white;
transition: none; }
.logo a span {
display: block;
margin-left: 20px; }
.logo .slogan {
color: #ea7d67;
font-style: italic;
margin-top: 10px;
margin-left: 60px; }
#block-system-main-menu ul {
font-size: 0;
position: relative; }
#block-system-main-menu li {
float: left;
list-style: none;
position: relative;
margin: 0;
padding: 0; }
#block-system-main-menu li ul {
display: none;
position: absolute;
top: 40px;
left: 0;
width: 150px; }
#block-system-main-menu li ul li {
display: block;
float: none; }
#block-system-main-menu li ul a {
cursor: pointer;
transition: color .3s ease;
color: #ea7d67;
display: block;
background-color: #555;
color: #f5f3e9;
border-bottom: #484848 1px solid; }
#block-system-main-menu li ul a:hover {
color: #ea7d67;
transition: none; }
#block-system-main-menu li:hover ul {
display: block; }
#block-system-main-menu li.first span {
padding-left: 30px; }
#block-system-main-menu li.last a {
padding-right: 30px; }
#block-system-main-menu li span, #block-system-main-menu li a {
cursor: pointer;
transition: color .3s ease;
color: #444444;
font-size: 14px;
font-weight: 300;
padding: 0 20px;
cursor: pointer;
text-transform: uppercase; }
#block-system-main-menu li span:hover, #block-system-main-menu li a:hover {
color: #ea7d67;
transition: none; }
#block-system-main-menu li span:hover, #block-system-main-menu li span.active, #block-system-main-menu li a:hover, #block-system-main-menu li a.active {
color: #fff; }
.menu-toggle {
display: none;
cursor: pointer; }
.front #main {
padding-top: 400px; }
.front #header .bot {
display: none; }
.front .logo {
top: 150px;
right: 50%;
margin-right: -330px; }
.front #ud-sm {
top: -180px; }
/* MAIN
-------------------------------------------------------------- */
#main-content {
width: 1100px;
margin: 0 auto;
z-index: 1;
position: relative; }
#main {
padding-top: 200px; }
.sidebar-first #main {
float: left;
width: 680px;
margin: 0 40px 0 0; }
.sidebar-first #side {
float: left;
width: 380px; }
/* SIDE
-------------------------------------------------------------- */
.side-content h2 {
color: #ea7d67;
font-size: 30px;
font-weight: 100;
text-align: center; }
.side-content .panel-pane {
background-color: #f1eee0;
padding: 0 0 20px;
margin-bottom: 20px;
/*border-bottom: #ccc 1px solid;*/
position: relative;
padding: 40px; }
.side-content .panel-pane h2.pane-title{
margin-top: 0;
}
.side-content .panel-pane .views-row + .views-row{
margin-top: 10px;
padding-top: 10px;
border-top: #f3b99f dashed 1px;
}
.side-content .panel-pane li{
margin-left: 0;
font-size: 14px;
}
.side-content .view-id-tweets li a{
color: #ea7d67;
}
#block-menu-menu-categories,
#block-views-content-block-1 {
text-align: center; }
#block-menu-menu-categories ul li,
#block-views-content-block-1 ul li {
margin: 0;
padding: 0; }
#block-menu-menu-categories .more-link,
#block-views-content-block-1 .more-link {
text-align: center; }
#follow {
text-align: center; }
#search-block-form input[type="text"] {
width: 80%;
float: left;
margin-right: 4px; }
.pane-menu-menu-categories {
text-align: center; }
#block-block-2 img {
width: 100%;
height: auto; }
.pane-block-2 img {
width: 100%;
height: auto; }
/* CONTACT
-------------------------------------------------------------- */
/* BIO
-------------------------------------------------------------- */
/* BLOG POST
-------------------------------------------------------------- */
.link,
.post {
margin-bottom: 60px;
padding-bottom: 60px;
/*border-bottom: #f3b99f dashed 1px;*/
position: relative; }
.link .header h2,
.post .header h2 {
font-size: 30px;
font-weight: 300;
margin-bottom: 5px;
font-family: "Lato", sans-serif;
font-weight: 300; }
.link .post-date,
.post .post-date {
/*font-size: 14px;
color: lighten($text_main, 40%);*/
color: #ea7d67;
font-size: 40px;
position: absolute;
top: -20px;
left: -20px;
font-weight: 100; }
.link .post-date-comments,
.post .post-date-comments {
font-size: 14px;
color: #aaaaaa; }
.link .comments_btn a,
.post .comments_btn a {
cursor: pointer;
transition: color .3s ease;
color: #ea7d67;
font-style: italic;
font-size: 14px; }
.link .comments_btn a:hover,
.post .comments_btn a:hover {
color: #444444;
transition: none; }
.link .body,
.post .body {
font-size: 14px; }
.post .body p{
font-size: 14px;
}
.link .footer,
.post .footer {
clear: both;
margin-top: 10px;
border-top: #ccc dashed 1px;
font-size: 12px;
padding-top: 10px; }
.link .footer h3,
.post .footer h3 {
font-weight: 400;
font-size: 12px;
text-transform: uppercase; }
.link .tags,
.post .tags {
font-size: 12px;
text-transform: uppercase;
width: 70%;
float: left; }
.link .tags h3,
.post .tags h3 {
display: inline-block; }
.link .tags a,
.post .tags a {
margin-left: 10px;
margin-bottom: 4px;
display: inline-block; }
.link .share,
.post .share {
float: right;
text-align: right; }
.link .share h3,
.post .share h3 {
margin-bottom: 5px; }
.link .share .service-links,
.post .share .service-links {
float: right; }
.link .service-links,
.post .service-links {
/* display: none; */ }
.post-teaser .header {
margin: 120px 5px 20px -20px;
border-left: #ea7d67 solid 5px;
padding: 0 0 0 15px; }
.post-teaser .main {
width: 680px;
float: left;
margin-right: 20px; }
.post-teaser .image {
background-color: #fff;
padding: 40px;
position: relative;
}
.post-teaser .image img {
width: 100%;
height: auto; }
.post-teaser .side {
float: left;
position: relative;
width: 380px; }
.post-teaser .read-more {
text-align: center;
}
.post-teaser .read-more a {
color: #ea7d67;
margin: 20px;
font-size: 40px;
font-weight: 100;
letter-spacing: 2px;
padding: 10px 20px;
display: inline-block;
text-transform: uppercase;
transition: all .3s ease; }
.post-teaser .read-more a:hover {
color: #444;
}
.post-teaser .footer a {
cursor: pointer;
transition: color .3s ease;
color: #aaaaaa; }
.post-teaser .footer a:hover {
color: #ea7d67;
transition: none; }
.post-teaser .footer .tags {
width: 30%;
font-weight: 400; }
.post-teaser .footer .tags a {
display: block;
padding: 0;
margin: 0 0 4px;;
text-transform: uppercase; }
.post-full .header {
text-align: center;
padding: 0 40px; }
.post-full .header h1 {
font-weight: 300;
font-size: 40px;
margin-bottom: 5px; }
.post-full .summary {
font-size: 14px;
padding: 20px 0;
border-top: #ccc 1px solid;
margin-top: 20px;
text-align: left; }
.post-full .body p {
padding: 10px 40px;
line-height: 24px;
margin: 0; }
.post-full .body a {
cursor: pointer;
transition: color .3s ease;
color: #ea7d67; }
.post-full .body a:hover {
color: #444444;
transition: none; }
.post-full .body h2, .post-full .body h3, .post-full .body h4, .post-full .body h5 {
padding: 0 40px;
font-weight: 300;
font-style: italic;
margin-top: 20px; }
.post-full .body h2 {
font-size: 30px; }
.post-full .body h3 {
font-size: 24px; }
.post-full .body h4 {
font-size: 18px; }
.post-full .body h2 + p, .post-full .body h3 + p, .post-full .body h4 + p {
padding-top: 10px; }
.post-full .body p.image-holder {
padding: 40px;
text-align: center;
background-color: #fff;
margin: 10px 0 20px; }
.post-full .body ul, .post-full .body ol {
padding: 10px 40px;
margin-left: 20px; }
.post-full .body ul li {
list-style: circle; }
.post-full .body ol li {
list-style: decimal; }
.post-full .body img {
width: 100%;
height: auto; }
.post .credits{
font-size: 12px;
text-transform: uppercase;
margin: 40px 0 20px;
}
.post .credits h2{
font-weight: 400;
font-size: 12px;
margin-bottom: 5px;
}
.item-list .pager{
margin-bottom: 60px;
font-size: 30px;
font-weight: 100;
text-transform: uppercase;
letter-spacing: 2px;
padding: 40px;
background-color: #f1eee0;
}
.item-list .pager a{
color: #ea7d67;
}
.item-list .pager a:hover{
color: #444;
}
.item-list .pager .pager-current{
font-weight: 100;
font-size: 20px;
}
.item-list .pager li{
margin: 0 40px 0;
}
/* LINKS
-------------------------------------------------------------- */
.link .image {
float: left;
margin-right: 20px; }
/* ABOUT & CONTACT
-------------------------------------------------------------- */
.left,
.right{
width: 48%;
float: left;
margin-bottom: 60px;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
.left{
margin-right: 4%;
}
.page-node-52 #main,
.page-node-53 #main{
}
.page-node-52 #main img,
.page-node-53 #main img{
max-width: 100%;
height: auto;
}
.page-node-53 #main h2{
font-weight: 100;
font-size: 60px;
margin-bottom: 40px;
}
.page-node-53 #main a{
font-size: 24px;
color: #ea7d67;
}
.page-node-53 #main a:hover{
color: #444;
}
.about-right,
.about-mid,
.about-left {
}
.about-left,
.about-right {
width: 48%;
margin: 20px auto; }
.about-mid {
width: 24%;
margin: 0 3%; }
.about-mid p {
font-size: 16px;
line-height: 30px;
text-align: justify; }
.about-page{
max-width: 750px;
margin: auto;
}
.about-page .left img,
.about-page .right img{
width: 100%;
height: auto;
}
.about-page h1{
text-align: center;
}
.team-member h2,
.team-member h3{
font-weight: 300;
text-align: center;
}
.team-member h2{
margin-top: 20px;
margin-bottom: 10px;
}
.team-member h3{
margin-bottom: 20px;
color: #ea7d67;
font-size: 16px;
text-transform: uppercase;
letter-spacing: 2px;
}
.contact-page{
text-align: center;
max-width: 750px;
margin: auto;
}
/* COMMENTS
-------------------------------------------------------------- */
.comments-holder {
margin: 30px auto 50px; }
.comments-header {
font-style: italic;
border-bottom: #ccc solid 1px;
margin-bottom: 30px; }
.comments-header h2 {
float: left;
font-size: 30px;
font-weight: 300; }
.comments-header .add-comment-btn {
color: #ea7d67;
float: right;
cursor: pointer;
text-transform: uppercase;
margin-top: 10px; }
.comment-form-holder {
padding: 30px 0 30px;
display: none;
border-bottom: #ccc dashed 1px; }
.comment-form {
width: 400px;
margin: 0 auto;
padding: 30px;
display: none;}
.page-comment-reply .comment-form {
display: block;
}
.page-comment-reply .comment{
margin: 20px auto 0;
}
.pane-node-comments {
padding-top: 20px; }
.comments {
margin: 0 auto;
padding: 30px 0; }
.comment {
width: 430px;
margin-bottom: 40px; }
.comment .comment-header {
margin: 0 5px 20px -20px;
border-left: #ea7d67 solid 5px;
padding: 0 0 0 15px; }
.comment .comment-header h2 {
font-size: 20px;
font-weight: 300; }
.comment .comment-header h3 {
font-size: 14px;
color: #ea7d67;
font-weight: 300;
font-style: italic; }
.comment .website a {
color: #ea7d67;
float: left; }
.comment .website a:hover {
color: #444444; }
.comment .submitted {
padding: 5px 10px;
background-color: #f2efe2;
font-size: 10px;
text-transform: uppercase; }
.comment .field-name-comment-body {
padding: 0;
font-size: 14px; }
.comment .footer {
clear: both;
margin-top: 10px;
border-top: #ccc dashed 1px;
font-size: 12px;
padding-top: 10px;
text-transform: uppercase; }
.comment .footer ul.links {
float: right;
text-align: right; }
/* SERVICE LINKS
-------------------------------------------------------------- */
.service-links li {
float: left;
margin-left: 10px; }
/* FOOTER
-------------------------------------------------------------- */
#footer {
position: relative;
clear: both;
background-color: #f1eee0;
font-size: 14px;
margin-top: 60px;
}
#footer h2{
color: #EA7D67;
font-size: 30px;
font-weight: 100;
text-align: center;
margin-bottom: 20px;
}
#copy{
background-color: #eae6d1;
line-height: 100px;
text-align: center;
}
#copy a{
color: #ea7d67;
}
#copy a:hover{
color: #444;
}
#footer-main{
max-width: 1100px;
margin: auto;
padding: 40px;
}
#block-instagram-block-instagram-block{
float: left;
margin-right: 4.5%;
width: 30%;
position: relative;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
#block-instagram-block-instagram-block img{
border: #fff 20px solid;
width: 100%;
height: auto;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
#block-views-tweets-block{
width: 30%;
float: left;
margin-right: 4.5%;
}
#block-views-tweets-block li + li{
margin-top: 10px;
padding-top: 10px;
border-top: #f3b99f dashed 1px;
}
#block-views-tweets-block a{
color: #ea7d67;
}
#block-block-1{
float: left;
width: 30%;
margin-top: 60px;
}
#block-mailchimp-lists-upstairs-downstairs-newsletter{
float: left;
width: 30%;
}
#block-mailchimp-lists-upstairs-downstairs-newsletter .form-submit{
float: right;
}
/* SOCIAL
-------------------------------------------------------------- */
.social-icons .icon {
background: #ea7d67 url(../images/bb_social.png) no-repeat;
height: 30px;
width: 30px;
display: inline-block;
border-radius: 15px;
margin: 10px 0 0 10px;
transition: background-color .3s ease; }
.social-icons .icon:hover {
background-color: #555;
}
.social-icons .twitter {
background-position: -30px 0; }
.social-icons .instagram {
background-position: -60px 0; }
.social-icons .youtube {
background-position: -90px 0; }
.social-icons .pinterest {
background-position: -120px 0; }
.social-icons.big{
padding-top: 40px;
}
.social-icons.big .icon {
margin-top: 40px;
background: #ea7d67 url(../images/bb_social_big.png) no-repeat;
height: 50px;
width: 50px;
display: inline-block;
border-radius: 25px;
margin: 10px 0 0 10px;
transition: background-color .3s ease; }
.social-icons.big .icon:hover {
background-color: #555;
}
.social-icons.big .twitter {
background-position: -50px 0; }
.social-icons.big .instagram {
background-position: -100px 0; }
.social-icons.big .youtube {
background-position: -150px 0; }
.social-icons.big .pinterest {
background-position: -200px 0; }
/* FORMS
-------------------------------------------------------------- */
.form-item {
margin-top: 0; }
input[type="text"],
input[type="password"],
input[type="email"],
textarea {
width: 98%;
padding: 5px 1%;
border: none;
background-color: white;
font-size: 18px;
font-family: "Lato";
font-weight: 300;
color: #c4c4c4;
box-shadow: 1px 1px 1px #ccc inset;
font-family: 'Lato', sans-serif; }
input[type="text"]:focus,
input[type="password"]:focus,
input[type="email"]:focus,
textarea:focus {
background-color: #fdfdfb;
color: #444444; }
label {
font-size: 16px;
font-style: italic;
font-weight: 300; }
input[type="submit"] {
background-color: #ea7d67;
color: #f5f3e9;
padding: 15px 20px 10px;
cursor: pointer;
font-size: 16px;
letter-spacing: 2px;
font-style: italic;
font-weight: 300;
border: none;
margin-left: 5px;
border-radius: 3px; }
input[type="submit"]:hover {
background-color: white;
color: #ea7d67; }
.form-actions {
text-align: right;
margin-bottom: 0; }
.marker, .form-required{
color: #ea7d67;
}
/* EXTRAS
-------------------------------------------------------------- */
body.cke_show_borders {
width: 680px !important;
min-width: 680px;
margin: 0 auto; }
.image-post_full {
position: relative;
z-index: 1; }
.hover-pinterest {
position: absolute;
right: 0px;
bottom: 0px;
z-index: 999;
background-image: url("../images/bb_pinit.png");
background-repeat: no-repeat;
background-position: bottom right;
display: none;
width: 100px;
height: 100px;
transition: all .3s ease;
opacity: .8; }
.hover-pinterest:hover {
opacity: 1; }
.hover-pinterest.show-pin-btn{
display: block;
}
.pin-it-link {
height: 100%;
width: 100%;
display: block; }
.front .messages-holder{
z-index: 10000;
position: absolute;
top: 100px;
}
.messages-holder .messages{
border: none !important;
margin: 40px 0;
}
.front .messages-holder .messages{
padding-right: 50px;
}
.messages-holder .messages li{
margin-bottom: 10px;
list-style: disc;
}
.messages-holder .messages.error{
background: none #ef9292;
color: #f5f3e9;
}
.messages-holder .messages.status{
background: none #8fba83;
color: #f5f3e9;
}
/* MOBILE
-------------------------------------------------------------- */
@media only screen and (max-width: 1120px) {
#main-content {
width: 100%;
margin: 0; }
#wrapper {
width: 100%; }
#u-big {
margin: 0;
left: -5%;
top: 60px;
width: 40%; }
#u-big img {
width: 100%;
height: auto; }
#d-big {
margin: 0;
left: 35%;
top: 80px;
width: 40%; }
#d-big img {
width: 100%;
height: auto; }
.page-node-53 #main a{
font-size: 18px;
}
#main {
padding: 180px 20px 0; }
.post-teaser .main {
width: 60%; }
.post-teaser .side {
width: 35%; }
.post-teaser .image {
padding: 20px; }
.sideright-bricks .main-content {
width: 60%; }
.sideright-bricks .side-content {
width: 37%;
margin-left: 3%; }
.side-content .pane-block {
padding: 20px; }
.comment {
width: 80%; }
.comment-form-holder {
clear: both; }
.comment-form-holder form {
padding: 0;
width: 100%; }
.comments-holder .header h2 {
font-size: 24px; }
.comments-holder .header .add-comment-btn {
font-size: 14px; } }
@media only screen and (max-width: 568px) {
#main-content {
width: 100%;
margin: 0; }
#main {
padding: 100px 20px 0; }
#header {
margin-bottom: 0;
text-align: center; }
#header #nav li {
float: none;
display: inline-block; }
#header #nav li a {
font-size: 12px;
padding: 0 10px; }
#header #header-inner {
float: none; }
#header #nav li ul li {
display: list-item;
text-align: left; }
.front #main {
padding-top: 200px; }
.logo {
float: none;
margin: 0 0 10px; }
.logo {
display: none; }
#u-big {
margin: 0;
left: 20px;
top: 60px; }
#u-big img {
width: 160px;
height: auto; }
.bot {
display: none; }
#d-big {
margin: 0;
left: 185px;
top: 80px; }
#d-big img {
width: 155px;
height: auto; }
#ud-sm #u-sm, #ud-sm #d-sm {
display: none; }
#ud-sm .logo {
display: none;
left: 20px;
text-align: left; }
/*.menu-toggle{display: block; margin-bottom: 10px;}*/
.sideright-bricks .main-content {
width: 100%; }
.sideright-bricks .side-content {
width: 100%;
margin-left: 0;
margin-top: 40px; }
.post-full .header h1 {
font-size: 30px; }
.post-full .body p.image-holder {
padding: 20px; }
.post-teaser .main {
width: 100%; }
.post-teaser .side {
width: 100%; }
.post-teaser .image {
padding: 20px; }
.post-teaser .header {
margin: 20px 0 0 -20px; }
#block-instagram-block-instagram-block,
#block-block-1,
#block-mailchimp-lists-upstairs-downstairs-newsletter,
#block-views-tweets-block{
float: none;
margin-right:0;
width: 100%;
margin-bottom: 60px;
}
}
| Java |
/* $Id$ */
/** @file
* IPRT - User & Kernel Memory, Ring-0 Driver, Solaris.
*/
/*
* Copyright (C) 2009 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include "the-solaris-kernel.h"
#include "internal/iprt.h"
#include <iprt/mem.h>
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
# include <iprt/asm-amd64-x86.h>
#endif
#include <iprt/assert.h>
#include <iprt/err.h>
RTR0DECL(int) RTR0MemUserCopyFrom(void *pvDst, RTR3PTR R3PtrSrc, size_t cb)
{
int rc;
RT_ASSERT_INTS_ON();
rc = ddi_copyin((const char *)R3PtrSrc, pvDst, cb, 0 /*flags*/);
if (RT_LIKELY(rc == 0))
return VINF_SUCCESS;
return VERR_ACCESS_DENIED;
}
RTR0DECL(int) RTR0MemUserCopyTo(RTR3PTR R3PtrDst, void const *pvSrc, size_t cb)
{
int rc;
RT_ASSERT_INTS_ON();
rc = ddi_copyout(pvSrc, (void *)R3PtrDst, cb, 0 /*flags*/);
if (RT_LIKELY(rc == 0))
return VINF_SUCCESS;
return VERR_ACCESS_DENIED;
}
RTR0DECL(bool) RTR0MemUserIsValidAddr(RTR3PTR R3Ptr)
{
return R3Ptr < kernelbase;
}
RTR0DECL(bool) RTR0MemKernelIsValidAddr(void *pv)
{
return (uintptr_t)pv >= kernelbase;
}
RTR0DECL(bool) RTR0MemAreKrnlAndUsrDifferent(void)
{
return true;
}
| Java |
/**
* @file g_func.c
* @brief func_* edicts
*/
/*
All original material Copyright (C) 2002-2011 UFO: Alien Invasion.
Original file from Quake 2 v3.21: quake2-2.31/game/g_spawn.c
Copyright (C) 1997-2001 Id Software, Inc.
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-1307, USA.
*/
#include "g_local.h"
/**
* @brief If an actor was standing on the breakable that is going to get destroyed, we have to let him fall to the ground
* @param self The breakable edict
* @param activator The touching edict
* @note This touch function is only executed if the func_breakable edict has a HP level of 0 (e.g. it is already destroyed)
* @return false because this is no client action
*/
static qboolean Touch_Breakable (edict_t *self, edict_t *activator)
{
/* not yet broken */
if (self->HP != 0)
return qfalse;
/** @todo check that the actor is standing upon the breakable */
if (G_IsActor(activator))
G_ActorFall(activator);
return qfalse;
}
static qboolean Destroy_Breakable (edict_t *self)
{
vec3_t origin;
const char *model = self->model;
VectorCenterFromMinsMaxs(self->absmin, self->absmax, origin);
/* the HP value is used to decide whether this was a triggered call or a
* call during a fight - a triggered call will be handled differently in
* terms of timing and the related particle effects in the client code */
if (self->HP == 0)
G_EventModelExplodeTriggered(self);
else
G_EventModelExplode(self);
if (self->particle)
G_SpawnParticle(origin, self->spawnflags, self->particle);
switch (self->material) {
case MAT_GLASS:
G_EventSpawnSound(PM_ALL, qfalse, self, origin, "misc/breakglass+");
break;
case MAT_METAL:
G_EventSpawnSound(PM_ALL, qfalse, self, origin, "misc/breakmetal+");
break;
case MAT_ELECTRICAL:
G_EventSpawnSound(PM_ALL, qfalse, self, origin, "misc/breakelectric+");
break;
case MAT_WOOD:
G_EventSpawnSound(PM_ALL, qfalse, self, origin, "misc/breakwood+");
break;
case MAT_MAX:
break;
}
G_TouchEdicts(self, 10.0f);
/* destroy the door trigger */
if (self->child)
G_FreeEdict(self->child);
/* now we can destroy the edict completely */
G_FreeEdict(self);
G_RecalcRouting(model);
return qtrue;
}
/**
* @brief func_breakable (0.3 0.3 0.3) ?
* Used for breakable objects.
* @note These edicts are added client side as local models,
* they are stored in the lmList (because they are inline models)
* for tracing (see inlineList in cmodel.c)
* @sa CM_EntTestLine
* @sa LM_AddModel
* @sa SV_SetModel
* @sa G_SendEdictsAndBrushModels
*/
void SP_func_breakable (edict_t *ent)
{
ent->classname = "breakable";
ent->type = ET_BREAKABLE;
ent->flags |= FL_DESTROYABLE;
/* set an inline model */
gi.SetModel(ent, ent->model);
ent->solid = SOLID_BSP;
gi.LinkEdict(ent);
Com_DPrintf(DEBUG_GAME, "func_breakable: model (%s) num: %i mins: %i %i %i maxs: %i %i %i origin: %i %i %i\n",
ent->model, ent->mapNum, (int)ent->mins[0], (int)ent->mins[1], (int)ent->mins[2],
(int)ent->maxs[0], (int)ent->maxs[1], (int)ent->maxs[2],
(int)ent->origin[0], (int)ent->origin[1], (int)ent->origin[2]);
ent->destroy = Destroy_Breakable;
ent->touch = Touch_Breakable;
}
/*
=============================================================================
DOOR FUNCTIONS
=============================================================================
*/
/**
* @brief Slides a door
* @note The new door state must already be set
* @param[in,out] door The entity of the inline model. The aabb of this bmodel will get updated
* in this function to reflect the new door position in the world
* @sa LET_SlideDoor
*/
static void Door_SlidingUse (edict_t *door)
{
const qboolean open = door->doorState == STATE_OPENED;
vec3_t moveAngles, moveDir, distanceVec;
int distance;
/* get the movement angle vector - a negative speed value will close the door*/
GET_SLIDING_DOOR_SHIFT_VECTOR(door->dir, open ? 1 : -1, moveAngles);
/* get the direction vector from the movement angles that were set on the entity */
AngleVectors(moveAngles, moveDir, NULL, NULL);
moveDir[0] = fabsf(moveDir[0]);
moveDir[1] = fabsf(moveDir[1]);
moveDir[2] = fabsf(moveDir[2]);
/* calculate the distance from the movement angles and the entity size. This is the
* distance the door has to slide to fully open or close */
distance = DotProduct(moveDir, door->size);
/* the door is moved in one step on the server side - lerping is not needed here - so we
* perform the scalar multiplication with the distance the door must move in order to
* fully close/open */
VectorMul(distance, moveAngles, distanceVec);
/* set the updated position. The bounding boxes that are used for tracing must be
* shifted when the door state changes. As the mins and maxs of the aabb are absolute
* world coordinates in the map we have to translate the position by the above
* calculated movement vector */
#if 0
/** @todo this is not yet working for tracing and pathfinding - check what must be done to
* allow shooting and walking through the opened door */
VectorAdd(door->origin, distanceVec, door->origin);
gi.SetInlineModelOrientation(door->model, door->origin, door->angles);
#else
VectorAdd(door->mins, distanceVec, door->mins);
VectorAdd(door->maxs, distanceVec, door->maxs);
#endif
}
/**
* @brief Opens/closes a door
* @note Use function for func_door
* @todo Check if the door can be opened or closed - there should not be
* anything in the way (e.g. an actor)
*/
static qboolean Door_Use (edict_t *door, edict_t *activator)
{
if (door->doorState == STATE_CLOSED) {
door->doorState = STATE_OPENED;
/* change rotation/origin and relink */
if (door->type == ET_DOOR) {
if (door->dir & DOOR_OPEN_REVERSE)
door->angles[door->dir & 3] -= DOOR_ROTATION_ANGLE;
else
door->angles[door->dir & 3] += DOOR_ROTATION_ANGLE;
} else if (door->type == ET_DOOR_SLIDING) {
Door_SlidingUse(door);
}
gi.LinkEdict(door);
/* maybe the server called this because the door starts opened */
if (G_MatchIsRunning()) {
/* let everybody know, that the door opens */
G_EventDoorOpen(door);
if (door->noise[0] != '\0')
G_EventSpawnSound(PM_ALL, qfalse, door, door->origin, door->noise);
}
} else if (door->doorState == STATE_OPENED) {
door->doorState = STATE_CLOSED;
/* change rotation and relink */
if (door->type == ET_DOOR) {
if (door->dir & DOOR_OPEN_REVERSE)
door->angles[door->dir & 3] += DOOR_ROTATION_ANGLE;
else
door->angles[door->dir & 3] -= DOOR_ROTATION_ANGLE;
} else if (door->type == ET_DOOR_SLIDING) {
Door_SlidingUse(door);
}
gi.LinkEdict(door);
/* closed is the standard, opened is handled above - we need an active
* team here already */
if (G_MatchIsRunning()) {
/* let everybody know, that the door closes */
G_EventDoorClose(door);
if (door->noise[0] != '\0')
G_EventSpawnSound(PM_ALL, qfalse, door, door->origin, door->noise);
}
} else
return qfalse;
/* Update model orientation */
gi.SetInlineModelOrientation(door->model, door->origin, door->angles);
Com_DPrintf(DEBUG_GAME, "Server processed door movement.\n");
/* Update path finding table */
G_RecalcRouting(door->model);
if (activator && G_IsLivingActor(activator)) {
/* Check if the player appears/perishes, seen from other teams. */
G_CheckVis(activator, qtrue);
/* Calc new vis for the activator. */
G_CheckVisTeamAll(activator->team, qfalse, activator);
}
return qtrue;
}
/**
* @brief Trigger to open the door we are standing in front of it
* @sa CL_DoorOpen
* @sa LE_CloseOpen
* @sa CL_ActorDoorAction
* @sa AI_CheckUsingDoor
*/
static qboolean Touch_DoorTrigger (edict_t *self, edict_t *activator)
{
if (self->owner && self->owner->inuse) {
if (G_IsAI(activator)) {
/* let the ai interact with the door */
if (self->flags & FL_GROUPSLAVE)
self = self->groupMaster;
if (AI_CheckUsingDoor(activator, self->owner))
G_ActorUseDoor(activator, self->owner);
/* we don't want the client action stuff to be send for ai actors */
return qfalse;
} else {
/* prepare for client action */
G_ActorSetClientAction(activator, self->owner);
return qtrue;
}
}
return qfalse;
}
/**
* @brief Left the door trigger zone - reset the client action
* @param self The trigger
* @param activator The edict that left the trigger zone
*/
static void Reset_DoorTrigger (edict_t *self, edict_t *activator)
{
if (activator->clientAction == self->owner)
G_ActorSetClientAction(activator, NULL);
}
#define REVERSE 0x00000200
/**
* @brief func_door (0 .5 .8) ?
* "health" if set, door is destroyable
* @sa SV_SetModel
* @sa LM_AddModel
* @sa G_SendEdictsAndBrushModels
*/
void SP_func_door (edict_t *ent)
{
edict_t *other;
ent->classname = "door";
ent->type = ET_DOOR;
if (!ent->noise)
ent->noise = "doors/open_close";
/* set an inline model */
gi.SetModel(ent, ent->model);
ent->solid = SOLID_BSP;
gi.LinkEdict(ent);
ent->doorState = STATE_CLOSED;
ent->dir = YAW;
if (ent->spawnflags & REVERSE)
ent->dir |= DOOR_OPEN_REVERSE;
if (ent->HP)
ent->flags |= FL_DESTROYABLE;
ent->flags |= FL_CLIENTACTION;
/* spawn the trigger entity */
other = G_TriggerSpawn(ent);
other->touch = Touch_DoorTrigger;
other->reset = Reset_DoorTrigger;
ent->child = other;
G_ActorSetTU(ent, TU_DOOR_ACTION);
ent->use = Door_Use;
/* the door should start opened */
if (ent->spawnflags & FL_TRIGGERED)
G_UseEdict(ent, NULL);
ent->destroy = Destroy_Breakable;
}
void SP_func_door_sliding (edict_t *ent)
{
ent->classname = "doorsliding";
ent->type = ET_DOOR_SLIDING;
if (!ent->noise)
ent->noise = "doors/slide";
/* set an inline model */
gi.SetModel(ent, ent->model);
ent->solid = SOLID_BSP;
gi.LinkEdict(ent);
if (ent->spawnflags & REVERSE)
ent->dir |= DOOR_OPEN_REVERSE;
if (ent->HP)
ent->flags |= FL_DESTROYABLE;
ent->doorState = STATE_CLOSED;
ent->speed = 10;
ent->use = Door_Use;
ent->destroy = Destroy_Breakable;
}
/**
* @brief Spawns a rotating solid inline brush model
* @sa SV_SetModel
* @sa LM_AddModel
*/
void SP_func_rotating (edict_t *ent)
{
ent->classname = "rotating";
ent->type = ET_ROTATING;
/* set an inline model */
gi.SetModel(ent, ent->model);
ent->solid = SOLID_BSP;
gi.LinkEdict(ent);
/* the lower, the faster */
if (!ent->speed)
ent->speed = 50;
if (ent->HP)
ent->flags |= FL_DESTROYABLE;
ent->destroy = Destroy_Breakable;
}
| Java |
<?php
include_once "../libs/myLib.php";
if (!isset($_SESSION['login'])) {
session_start();
}
$nombre = $_POST['nombre'];
$fechaInicio= $_POST['fechaInicio'];
$horaInicio = $_POST['horaInicio'];
$fechaFin = $_POST['fechaInicio'];
$horaFin = $_POST['horaFin'];
$precio = $_POST['precio'];
$plazas = $_POST['plazas'];
$descripcion = $_POST['descripcion'];
$requisitos = $_POST['requisitos'];
$imagen = "assets/img/evento.png";
$empresa = "";
$usuario = "";
$fechaI = $fechaInicio.' '.$horaInicio;
$fechaF = $fechaFin.' '.$horaFin;
$todoInicio = date('Y-m-d H:i:s', strtotime($fechaI));
$todoFin = date('Y-m-d H:i:s', strtotime($fechaF));
$salir = false;
if ($_POST['empresa'] != "" && $_POST['usuario'] == ""){
$empresa = $_POST['empresa'];
$sql = "INSERT INTO evento (nombre,fechaInicio,fechaFin,precio,plazas,descripcion,requisitos,empresa,imagen)
VALUES ('$nombre','$todoInicio','$todoFin','$precio','$plazas','$descripcion','$requisitos','$empresa','$imagen')";
} else if ($_POST['empresa'] == "" && $_POST['usuario'] != ""){
$usuario = $_POST['usuario'];
$sql = "INSERT INTO evento (nombre,fechaInicio,fechaFin,precio,plazas,descripcion,requisitos,usuario,imagen)
VALUES ('$nombre','$todoInicio','$todoFin','$precio','$plazas','$descripcion','$requisitos','$usuario','$imagen')";
} else {
$salir = true;
}
if (!$salir) {
$conexion = dbConnect();
$resultado = mysqli_query($conexion, $sql);
if ($resultado) {
if (isset($_FILES['imagen']) && $_FILES['imagen']['name']) {
$subidaCorrecta = false;
$sql = "SELECT id FROM evento WHERE id=@@Identity";
$resultado = mysqli_query($conexion, $sql);
$row = mysqli_fetch_array($resultado);
$id = $row['id'];
if ($_FILES['imagen']['error'] > 0) {
salir2("Ha ocurrido un error en la carga de la imagen", -1, "gestionarEventos.php");
} else {
$extensiones = array("image/jpg", "image/jpeg", "image/png");
$limite = 4096;
if (in_array($_FILES['imagen']['type'], $extensiones) && $_FILES['imagen']['size'] < $limite * 1024) {
$foldername = "assets/img/eventos";
$foldermkdir = "../" . $foldername;
if (!is_dir($foldermkdir)) {
mkdir($foldermkdir, 0777, true);
}
$extension = "." . split("/", $_FILES['imagen']['type'])[1];
$filename = $id . $extension;
$ruta = $foldername . "/" . $filename;
$rutacrear = $foldermkdir . "/" . $filename;
if (!file_exists($rutacrear)) {
$subidaCorrecta = @move_uploaded_file($_FILES['imagen']['tmp_name'], $rutacrear);
$imagen = $ruta;
}
}
if ($subidaCorrecta) {
$sql = "UPDATE evento SET imagen='$imagen' WHERE id=$id";
$resultado = mysqli_query($conexion, $sql);
mysqli_close($conexion);
if ($resultado) {
salir2("Evento añadido correctamente", 0, "gestionarEventos.php");
} else {
salir2("Ha ocurrido un error con la imagen", -1, "gestionarEventos.php");
}
} else { // No se ha subido la imagen
mysqli_close($conexion);
salir2("Ha ocurrido un error subiendo la imagen", -1, "gestionarEventos.php");
}
}
} else { // No hay imagen
mysqli_close($conexion);
salir2("Evento añadido correctamente", 0, "gestionarEventos.php");
}
} else { // Fallo en INSERT
mysqli_close($conexion);
salir2("Error añadiendo el evento", -1, "gestionarEventos.php");
}
} else {
salir2("No se ha introducido correctamente el organizador", -1, "gestionarEventos.php");
}
?>
| Java |
/*
* This file is part of the OregonCore Project. See AUTHORS file for Copyright information
*
* 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, see <https://www.gnu.org/licenses/>.
*/
/* ScriptData
SDName: Boss_Moam
SD%Complete: 100
SDComment: VERIFY SCRIPT AND SQL
SDCategory: Ruins of Ahn'Qiraj
EndScriptData */
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#define EMOTE_AGGRO -1509000
#define EMOTE_MANA_FULL -1509001
#define SPELL_TRAMPLE 15550
#define SPELL_DRAINMANA 27256
#define SPELL_ARCANEERUPTION 25672
#define SPELL_SUMMONMANA 25681
#define SPELL_GRDRSLEEP 24360 //Greater Dreamless Sleep
struct boss_moamAI : public ScriptedAI
{
boss_moamAI(Creature* c) : ScriptedAI(c) {}
Unit* pTarget;
uint32 TRAMPLE_Timer;
uint32 DRAINMANA_Timer;
uint32 SUMMONMANA_Timer;
uint32 i;
uint32 j;
void Reset()
{
i = 0;
j = 0;
pTarget = NULL;
TRAMPLE_Timer = 30000;
DRAINMANA_Timer = 30000;
}
void EnterCombat(Unit* who)
{
DoScriptText(EMOTE_AGGRO, me);
pTarget = who;
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
//If we are 100%MANA cast Arcane Erruption
//if (j == 1 && me->GetMana()*100 / me->GetMaxMana() == 100 && !me->IsNonMeleeSpellCast(false))
{
DoCastVictim(SPELL_ARCANEERUPTION);
DoScriptText(EMOTE_MANA_FULL, me);
}
//If we are <50%HP cast MANA FIEND (Summon Mana) and Sleep
//if (i == 0 && me->GetHealth()*100 / me->GetMaxHealth() <= 50 && !me->IsNonMeleeSpellCast(false))
{
i = 1;
DoCastVictim(SPELL_SUMMONMANA);
DoCastVictim(SPELL_GRDRSLEEP);
}
//SUMMONMANA_Timer
if (i == 1 && SUMMONMANA_Timer <= diff)
{
DoCastVictim(SPELL_SUMMONMANA);
SUMMONMANA_Timer = 90000;
}
else SUMMONMANA_Timer -= diff;
//TRAMPLE_Timer
if (TRAMPLE_Timer <= diff)
{
DoCastVictim(SPELL_TRAMPLE);
j = 1;
TRAMPLE_Timer = 30000;
}
else TRAMPLE_Timer -= diff;
//DRAINMANA_Timer
if (DRAINMANA_Timer <= diff)
{
DoCastVictim(SPELL_DRAINMANA);
DRAINMANA_Timer = 30000;
}
else DRAINMANA_Timer -= diff;
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI_boss_moam(Creature* pCreature)
{
return new boss_moamAI (pCreature);
}
void AddSC_boss_moam()
{
Script* newscript;
newscript = new Script;
newscript->Name = "boss_moam";
newscript->GetAI = &GetAI_boss_moam;
newscript->RegisterSelf();
}
| Java |
.block-ebog_banner .content {
position: relative;
}
.block-ebog_banner .bottom-bar {
background-clip: padding-box;
-webkit-background-clip: padding-box;
-moz-background-clip: padding;
background-color: #1b75bc;
border-radius: 0 0 4px 4px;
-moz-border-radius: 0 0 4px 4px;
-webkit-border-radius: 0 0 4px 4px;
bottom: 0;
height: 26px;
left: 0;
position: absolute;
width: 100%;
}
.block-ebog_banner .bottom-bar a {
color: #fff;
line-height: 26px;
padding: 3px 7px;
text-decoration: none;
}
.block-ebog_banner .bottom-bar a:hover {
border-radius: 4px;
-webkit-border-radius: 4px;
-moz-border-radius: 4px;
box-shadow: inset 0 0 3px #000000;
-webkit-box-shadow: inset 0 0 3px #000000;
-moz-box-shadow: inset 0 0 3px #000000;
border: 1px solid #3069b3;
padding: 2px 6px;
text-decoration: underline;
}
.block-ebog_banner .ebog-banner-image img {
height: auto;
width: 100%;
}
| Java |
<!DOCTYPE html>
<html class="no-js" lang="en">
<head>
<meta charset="utf-8">
<title>Titanium Rings Forever style guide</title>
<meta name="description" content="">
<meta name="generator" content="kss-node">
<meta name="viewport" content="width=device-width">
<link rel="stylesheet" href="kss-assets/kss.css">
<link rel="stylesheet" href="//brick.a.ssl.fastly.net/Lora:400i/Roboto:500,300,700,900">
<link rel="stylesheet" href="../../css/styles.css">
<link rel="stylesheet" href="../../css/styleguide.css">
</head>
<body id="kss-node" class="kss-fullscreen-mode">
<div class="kss-sidebar kss-style">
<header class="kss-header">
<h1 class="kss-doc-title">Titanium Rings Forever style guide</h1>
</header>
<nav class="kss-nav">
<ul class="kss-nav__menu">
<li class="kss-nav__menu-item">
<a class="kss-nav__menu-link" href="./">
<span class="kss-nav__ref">0</span
><span class="kss-nav__name">Overview</span>
</a>
</li>
<li class="kss-nav__menu-item">
<a class="kss-nav__menu-link" href="section-variables.html">
<span class="kss-nav__ref">1</span><span class="kss-nav__name">Variables</span>
</a>
</li>
<li class="kss-nav__menu-item">
<a class="kss-nav__menu-link" href="section-base.html">
<span class="kss-nav__ref">2</span><span class="kss-nav__name">Base defaults</span>
</a>
</li>
<li class="kss-nav__menu-item">
<a class="kss-nav__menu-link" href="section-components.html">
<span class="kss-nav__ref">3</span><span class="kss-nav__name">Components</span>
</a>
</li>
<li class="kss-nav__menu-item">
<a class="kss-nav__menu-link" href="section-modules.html">
<span class="kss-nav__ref">4</span><span class="kss-nav__name">Modules</span>
</a>
</li>
</ul>
</nav>
</div>
<article role="main" class="kss-main">
<div id="kssref-base-type-headers" class="kss-section kss-section--depth-3 is-fullscreen">
<div class="kss-style">
<h3 class="kss-title kss-title--level-3">
<a class="kss-title__permalink" href="#kssref-base-type-headers">
<span class="kss-title__ref">
2.3.3
<span class="kss-title__permalink-hash">
#base.type.headers
</span>
</span>
Headers
</a>
</h3>
</div>
<div class="kss-source kss-style">
Source: <code>base/typography/_headers.scss</code>, line 1
</div>
</div>
</article>
<!-- SCRIPTS -->
<script src="kss-assets/kss.js"></script>
<script src="kss-assets/scrollspy.js"></script>
<script src="kss-assets/prettify.js"></script>
<script src="kss-assets/kss-fullscreen.js"></script>
<script src="kss-assets/kss-guides.js"></script>
<script src="kss-assets/kss-markup.js"></script>
<script>
prettyPrint();
var spy = new ScrollSpy('#kss-node', {
nav: '.kss-nav__menu-child > li > a',
className: 'is-in-viewport'
});
var kssFullScreen = new KssFullScreen({
idPrefix: 'kss-fullscreen-',
bodyClass: 'kss-fullscreen-mode',
elementClass: 'is-fullscreen'
});
var kssGuides = new KssGuides({
bodyClass: 'kss-guides-mode'
});
var kssMarkup = new KssMarkup({
bodyClass: 'kss-markup-mode',
detailsClass: 'kss-markup'
});
</script>
<script src="../../js/fastclick.min.js"></script>
<script src="../../js/jquery.tooltipster.min.js"></script>
<script src="../../js/trf.js"></script>
<script src="../../js/styleguide_slideout.min.js"></script>
<script src="../../js/styleguide.js"></script>
<!-- Automatically built using <a href="https://github.com/kss-node/kss-node">kss-node</a>. -->
</body>
</html>
| Java |
/*
* Copyright (c) 2006 - 2012 LinogistiX GmbH
*
* www.linogistix.com
*
* Project myWMS-LOS
*/
package de.linogistix.los.reference.customization.common;
import javax.ejb.Stateless;
import de.linogistix.los.customization.LOSEventConsumerBean;
import de.linogistix.los.util.event.LOSEventConsumer;
/**
* @author krane
*
*/
@Stateless
public class Ref_EventConsumerBean extends LOSEventConsumerBean implements LOSEventConsumer {
}
| Java |
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://lammps.sandia.gov/, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "fix_nve.h"
#include "atom.h"
#include "error.h"
#include "force.h"
#include "respa.h"
#include "update.h"
using namespace LAMMPS_NS;
using namespace FixConst;
/* ---------------------------------------------------------------------- */
FixNVE::FixNVE(LAMMPS *lmp, int narg, char **arg) :
Fix(lmp, narg, arg)
{
if (!utils::strmatch(style,"^nve/sphere") && narg < 3)
error->all(FLERR,"Illegal fix nve command");
dynamic_group_allow = 1;
time_integrate = 1;
}
/* ---------------------------------------------------------------------- */
int FixNVE::setmask()
{
int mask = 0;
mask |= INITIAL_INTEGRATE;
mask |= FINAL_INTEGRATE;
mask |= INITIAL_INTEGRATE_RESPA;
mask |= FINAL_INTEGRATE_RESPA;
return mask;
}
/* ---------------------------------------------------------------------- */
void FixNVE::init()
{
dtv = update->dt;
dtf = 0.5 * update->dt * force->ftm2v;
if (utils::strmatch(update->integrate_style,"^respa"))
step_respa = ((Respa *) update->integrate)->step;
}
/* ----------------------------------------------------------------------
allow for both per-type and per-atom mass
------------------------------------------------------------------------- */
void FixNVE::initial_integrate(int /*vflag*/)
{
double dtfm;
// update v and x of atoms in group
double **x = atom->x;
double **v = atom->v;
double **f = atom->f;
double *rmass = atom->rmass;
double *mass = atom->mass;
int *type = atom->type;
int *mask = atom->mask;
int nlocal = atom->nlocal;
if (igroup == atom->firstgroup) nlocal = atom->nfirst;
if (rmass) {
for (int i = 0; i < nlocal; i++)
if (mask[i] & groupbit) {
dtfm = dtf / rmass[i];
v[i][0] += dtfm * f[i][0];
v[i][1] += dtfm * f[i][1];
v[i][2] += dtfm * f[i][2];
x[i][0] += dtv * v[i][0];
x[i][1] += dtv * v[i][1];
x[i][2] += dtv * v[i][2];
}
} else {
for (int i = 0; i < nlocal; i++)
if (mask[i] & groupbit) {
dtfm = dtf / mass[type[i]];
v[i][0] += dtfm * f[i][0];
v[i][1] += dtfm * f[i][1];
v[i][2] += dtfm * f[i][2];
x[i][0] += dtv * v[i][0];
x[i][1] += dtv * v[i][1];
x[i][2] += dtv * v[i][2];
}
}
}
/* ---------------------------------------------------------------------- */
void FixNVE::final_integrate()
{
double dtfm;
// update v of atoms in group
double **v = atom->v;
double **f = atom->f;
double *rmass = atom->rmass;
double *mass = atom->mass;
int *type = atom->type;
int *mask = atom->mask;
int nlocal = atom->nlocal;
if (igroup == atom->firstgroup) nlocal = atom->nfirst;
if (rmass) {
for (int i = 0; i < nlocal; i++)
if (mask[i] & groupbit) {
dtfm = dtf / rmass[i];
v[i][0] += dtfm * f[i][0];
v[i][1] += dtfm * f[i][1];
v[i][2] += dtfm * f[i][2];
}
} else {
for (int i = 0; i < nlocal; i++)
if (mask[i] & groupbit) {
dtfm = dtf / mass[type[i]];
v[i][0] += dtfm * f[i][0];
v[i][1] += dtfm * f[i][1];
v[i][2] += dtfm * f[i][2];
}
}
}
/* ---------------------------------------------------------------------- */
void FixNVE::initial_integrate_respa(int vflag, int ilevel, int /*iloop*/)
{
dtv = step_respa[ilevel];
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
// innermost level - NVE update of v and x
// all other levels - NVE update of v
if (ilevel == 0) initial_integrate(vflag);
else final_integrate();
}
/* ---------------------------------------------------------------------- */
void FixNVE::final_integrate_respa(int ilevel, int /*iloop*/)
{
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
final_integrate();
}
/* ---------------------------------------------------------------------- */
void FixNVE::reset_dt()
{
dtv = update->dt;
dtf = 0.5 * update->dt * force->ftm2v;
}
| Java |
<?php
/**
* @file
* Zen theme's implementation for comments.
*
* Available variables:
* - $author: Comment author. Can be link or plain text.
* - $content: An array of comment items. Use render($content) to print them all, or
* print a subset such as render($content['field_example']). Use
* hide($content['field_example']) to temporarily suppress the printing of a
* given element.
* - $created: Formatted date and time for when the comment was created.
* Preprocess functions can reformat it by calling format_date() with the
* desired parameters on the $comment->created variable.
* - $pubdate: Formatted date and time for when the comment was created wrapped
* in a HTML5 time element.
* - $changed: Formatted date and time for when the comment was last changed.
* Preprocess functions can reformat it by calling format_date() with the
* desired parameters on the $comment->changed variable.
* - $new: New comment marker.
* - $permalink: Comment permalink.
* - $submitted: Submission information created from $author and $created during
* template_preprocess_comment().
* - $picture: Authors picture.
* - $signature: Authors signature.
* - $status: Comment status. Possible values are:
* comment-unpublished, comment-published or comment-preview.
* - $title: Linked title.
* - $classes: String of classes that can be used to style contextually through
* CSS. It can be manipulated through the variable $classes_array from
* preprocess functions. The default values can be one or more of the following:
* - comment: The current template type, i.e., "theming hook".
* - comment-by-anonymous: Comment by an unregistered user.
* - comment-by-node-author: Comment by the author of the parent node.
* - comment-preview: When previewing a new or edited comment.
* - first: The first comment in the list of displayed comments.
* - last: The last comment in the list of displayed comments.
* - odd: An odd-numbered comment in the list of displayed comments.
* - even: An even-numbered comment in the list of displayed comments.
* The following applies only to viewers who are registered users:
* - comment-unpublished: An unpublished comment visible only to administrators.
* - comment-by-viewer: Comment by the user currently viewing the page.
* - comment-new: New comment since the last visit.
* - $title_prefix (array): An array containing additional output populated by
* modules, intended to be displayed in front of the main title tag that
* appears in the template.
* - $title_suffix (array): An array containing additional output populated by
* modules, intended to be displayed after the main title tag that appears in
* the template.
*
* These two variables are provided for context:
* - $comment: Full comment object.
* - $node: Node object the comments are attached to.
*
* Other variables:
* - $classes_array: Array of html class attribute values. It is flattened
* into a string within the variable $classes.
*
* @see template_preprocess()
* @see template_preprocess_comment()
* @see zen_preprocess_comment()
* @see template_process()
* @see theme_comment()
*/
?>
<article class="<?php print $classes; ?> clearfix"<?php print $attributes; ?>>
<header>
<p class="submitted">
<?php
print 'Dodany przez '.$author.' <i>(dnia: '.format_date($node->created, 'custom', 'd.m.Y').')</i>';
?>
</p>
<?php print render($title_prefix); ?>
<?php if ($title): ?>
<h3<?php print $title_attributes; ?>>
<?php print $title; ?>
<?php if ($new): ?>
<mark class="new"><?php print $new; ?></mark>
<?php endif; ?>
</h3>
<?php elseif ($new): ?>
<mark class="new"><?php print $new; ?></mark>
<?php endif; ?>
<?php print render($title_suffix); ?>
<?php if ($status == 'comment-unpublished'): ?>
<p class="unpublished"><?php print t('Unpublished'); ?></p>
<?php endif; ?>
</header>
<?php
// We hide the comments and links now so that we can render them later.
hide($content['links']);
print render($content);
?>
<?php if ($signature): ?>
<footer class="user-signature clearfix">
<?php print $signature; ?>
</footer>
<?php endif; ?>
<?php print render($content['links']) ?>
</article><!-- /.comment -->
| Java |
<?php
namespace Drupal\commerce_order;
use Drupal\commerce_price\Price;
/**
* Represents an adjustment.
*/
final class Adjustment {
/**
* The adjustment type.
*
* @var string
*/
protected $type;
/**
* The adjustment label.
*
* @var string
*/
protected $label;
/**
* The adjustment amount.
*
* @var \Drupal\commerce_price\Price
*/
protected $amount;
/**
* The adjustment percentage.
*
* @var string
*/
protected $percentage;
/**
* The source identifier of the adjustment.
*
* Points to the source object, if known. For example, a promotion entity for
* a discount adjustment.
*
* @var string
*/
protected $sourceId;
/**
* Whether the adjustment is included in the base price.
*
* @var bool
*/
protected $included = FALSE;
/**
* Whether the adjustment is locked.
*
* @var bool
*/
protected $locked = FALSE;
/**
* Constructs a new Adjustment object.
*
* @param array $definition
* The definition.
*/
public function __construct(array $definition) {
foreach (['type', 'label', 'amount'] as $required_property) {
if (empty($definition[$required_property])) {
throw new \InvalidArgumentException(sprintf('Missing required property %s.', $required_property));
}
}
if (!$definition['amount'] instanceof Price) {
throw new \InvalidArgumentException(sprintf('Property "amount" should be an instance of %s.', Price::class));
}
$adjustment_type_manager = \Drupal::service('plugin.manager.commerce_adjustment_type');
$types = $adjustment_type_manager->getDefinitions();
if (empty($types[$definition['type']])) {
throw new \InvalidArgumentException(sprintf('%s is an invalid adjustment type.', $definition['type']));
}
if (!empty($definition['percentage'])) {
if (is_float($definition['percentage'])) {
throw new \InvalidArgumentException(sprintf('The provided percentage "%s" must be a string, not a float.', $definition['percentage']));
}
if (!is_numeric($definition['percentage'])) {
throw new \InvalidArgumentException(sprintf('The provided percentage "%s" is not a numeric value.', $definition['percentage']));
}
}
// Assume that 'custom' adjustments are always locked, for BC reasons.
if ($definition['type'] == 'custom' && !isset($definition['locked'])) {
$definition['locked'] = TRUE;
}
$this->type = $definition['type'];
$this->label = (string) $definition['label'];
$this->amount = $definition['amount'];
$this->percentage = !empty($definition['percentage']) ? $definition['percentage'] : NULL;
$this->sourceId = !empty($definition['source_id']) ? $definition['source_id'] : NULL;
$this->included = !empty($definition['included']);
$this->locked = !empty($definition['locked']);
}
/**
* Gets the adjustment type.
*
* @return string
* The adjustment type.
*/
public function getType() {
return $this->type;
}
/**
* Gets the adjustment label.
*
* @return string
* The adjustment label.
*/
public function getLabel() {
return $this->label;
}
/**
* Gets the adjustment amount.
*
* @return \Drupal\commerce_price\Price
* The adjustment amount.
*/
public function getAmount() {
return $this->amount;
}
/**
* Gets whether the adjustment is positive.
*
* @return bool
* TRUE if the adjustment is positive, FALSE otherwise.
*/
public function isPositive() {
return $this->amount->getNumber() >= 0;
}
/**
* Gets whether the adjustment is negative.
*
* @return bool
* TRUE if the adjustment is negative, FALSE otherwise.
*/
public function isNegative() {
return $this->amount->getNumber() < 0;
}
/**
* Gets the adjustment percentage.
*
* @return string|null
* The percentage as a decimal. For example, "0.2" for a 20% adjustment.
* Otherwise NULL, if the adjustment was not calculated from a percentage.
*/
public function getPercentage() {
return $this->percentage;
}
/**
* Get the source identifier.
*
* @return string
* The source identifier.
*/
public function getSourceId() {
return $this->sourceId;
}
/**
* Gets whether the adjustment is included in the base price.
*
* @return bool
* TRUE if the adjustment is included in the base price, FALSE otherwise.
*/
public function isIncluded() {
return $this->included;
}
/**
* Gets whether the adjustment is locked.
*
* Locked adjustments are not removed during the order refresh process.
*
* @return bool
* TRUE if the adjustment is locked, FALSE otherwise.
*/
public function isLocked() {
return $this->locked;
}
/**
* Gets the array representation of the adjustment.
*
* @return array
* The array representation of the adjustment.
*/
public function toArray() {
return [
'type' => $this->type,
'label' => $this->label,
'amount' => $this->amount,
'percentage' => $this->percentage,
'source_id' => $this->sourceId,
'included' => $this->included,
'locked' => $this->locked,
];
}
/**
* Adds the given adjustment to the current adjustment.
*
* @param \Drupal\commerce_order\Adjustment $adjustment
* The adjustment.
*
* @return static
* The resulting adjustment.
*/
public function add(Adjustment $adjustment) {
$this->assertSameType($adjustment);
$this->assertSameSourceId($adjustment);
$definition = [
'amount' => $this->amount->add($adjustment->getAmount()),
] + $this->toArray();
return new static($definition);
}
/**
* Subtracts the given adjustment from the current adjustment.
*
* @param \Drupal\commerce_order\Adjustment $adjustment
* The adjustment.
*
* @return static
* The resulting adjustment.
*/
public function subtract(Adjustment $adjustment) {
$this->assertSameType($adjustment);
$this->assertSameSourceId($adjustment);
$definition = [
'amount' => $this->amount->subtract($adjustment->getAmount()),
] + $this->toArray();
return new static($definition);
}
/**
* Multiplies the adjustment amount by the given number.
*
* @param string $number
* The number.
*
* @return static
* The resulting adjustment.
*/
public function multiply($number) {
$definition = [
'amount' => $this->amount->multiply($number),
] + $this->toArray();
return new static($definition);
}
/**
* Divides the adjustment amount by the given number.
*
* @param string $number
* The number.
*
* @return static
* The resulting adjustment.
*/
public function divide($number) {
$definition = [
'amount' => $this->amount->divide($number),
] + $this->toArray();
return new static($definition);
}
/**
* Asserts that the given adjustment's type matches the current one.
*
* @param \Drupal\commerce_order\Adjustment $adjustment
* The adjustment to compare.
*
* @throws \InvalidArgumentException
* Thrown when the adjustment type does not match the current one.
*/
protected function assertSameType(Adjustment $adjustment) {
if ($this->type != $adjustment->getType()) {
throw new \InvalidArgumentException(sprintf('Adjustment type "%s" does not match "%s".', $adjustment->getType(), $this->type));
}
}
/**
* Asserts that the given adjustment's source ID matches the current one.
*
* @param \Drupal\commerce_order\Adjustment $adjustment
* The adjustment to compare.
*
* @throws \InvalidArgumentException
* Thrown when the adjustment source ID does not match the current one.
*/
protected function assertSameSourceId(Adjustment $adjustment) {
if ($this->sourceId != $adjustment->getSourceId()) {
throw new \InvalidArgumentException(sprintf('Adjustment source ID "%s" does not match "%s".', $adjustment->getSourceId(), $this->sourceId));
}
}
}
| Java |
package xyz.zyzhu.model;
import org.junit.*;
import org.junit.Assert.*;
public class TestHelloWorld
{
@Test
public void tesySayHello()
{
Assert.assertEquals("hello world",new HelloWorld().sayHello());
}
} | Java |
/*
* blockio.cc
*
*
*/
#define _LARGEFILE_SOURCE
#define _FILE_OFFSET_BITS 64
#include "version.h"
#include "blockio.h"
#include "osutils.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>
__ID("@(#) $Id: blockio.cc 2069 2009-02-12 22:53:09Z lyonel $");
ssize_t readlogicalblocks(source & s,
void * buffer,
long long pos, long long count)
{
long long result = 0;
memset(buffer, 0, count*s.blocksize);
/* attempt to read past the end of the section */
if((s.size>0) && ((pos+count)*s.blocksize>s.size)) return 0;
result = lseek(s.fd, s.offset + pos*s.blocksize, SEEK_SET);
if(result == -1) return 0;
result = read(s.fd, buffer, count*s.blocksize);
if(result!=count*s.blocksize)
return 0;
else
return count;
}
| Java |
/*
* Copyright (C) 2003 Robert Kooima
*
* NEVERBALL 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.
*/
#include <math.h>
#include "vec3.h"
#include "common.h"
#include "solid_vary.h"
#include "solid_sim.h"
#include "solid_all.h"
#include "solid_cmd.h"
#define LARGE 1.0e+5f
#define SMALL 1.0e-3f
/*---------------------------------------------------------------------------*/
/* Solves (p + v * t) . (p + v * t) == r * r for smallest t. */
/*
* Given vectors A = P, B = V * t, C = A + B, |C| = r, solve for
* smallest t.
*
* Some useful dot product properties:
*
* 1) A . A = |A| * |A|
* 2) A . (B + C) = A . B + A . C
* 3) (r * A) . B = r * (A . B)
*
* Deriving a quadratic equation:
*
* C . C = r * r (1)
* (A + B) . (A + B) = r * r
* A . (A + B) + B . (A + B) = r * r (2)
* A . A + A . B + B . A + B . B = r * r (2)
* A . A + 2 * (A . B) + B . B = r * r
* P . P + 2 * (P . V * t) + (V * t . V * t) = r * r
* P . P + 2 * (P . V) * t + (V . V) * t * t = r * r (3)
* (V . V) * t * t + 2 * (P . V) * t + P . P - r * r = 0
*
* This equation is solved using the quadratic formula.
*/
static float v_sol(const float p[3], const float v[3], float r)
{
float a = v_dot(v, v);
float b = v_dot(v, p) * 2.0f;
float c = v_dot(p, p) - r * r;
float d = b * b - 4.0f * a * c;
/* HACK: This seems to cause failures to detect low-velocity collision
Yet, the potential division by zero below seems fine.
if (fabsf(a) < SMALL) return LARGE;
*/
if (d < 0.0f) return LARGE;
else if (d > 0.0f)
{
float t0 = 0.5f * (-b - fsqrtf(d)) / a;
float t1 = 0.5f * (-b + fsqrtf(d)) / a;
float t = (t0 < t1) ? t0 : t1;
return (t < 0.0f) ? LARGE : t;
}
else return -b * 0.5f / a;
}
/*---------------------------------------------------------------------------*/
/*
* Compute the earliest time and position of the intersection of a
* sphere and a vertex.
*
* The sphere has radius R and moves along vector V from point P. The
* vertex moves along vector W from point Q in a coordinate system
* based at O.
*/
static float v_vert(float Q[3],
const float o[3],
const float q[3],
const float w[3],
const float p[3],
const float v[3], float r)
{
float O[3], P[3], V[3];
float t = LARGE;
v_add(O, o, q);
v_sub(P, p, O);
v_sub(V, v, w);
if (v_dot(P, V) < 0.0f)
{
t = v_sol(P, V, r);
if (t < LARGE)
v_mad(Q, O, w, t);
}
return t;
}
/*
* Compute the earliest time and position of the intersection of a
* sphere and an edge.
*
* The sphere has radius R and moves along vector V from point P. The
* edge moves along vector W from point Q in a coordinate system based
* at O. The edge extends along the length of vector U.
*/
static float v_edge(float Q[3],
const float o[3],
const float q[3],
const float u[3],
const float w[3],
const float p[3],
const float v[3], float r)
{
float d[3], e[3];
float P[3], V[3];
float du, eu, uu, s, t;
v_sub(d, p, o);
v_sub(d, d, q);
v_sub(e, v, w);
/*
* Think projections. Vectors D, extending from the edge vertex Q
* to the sphere, and E, the relative velocity of sphere wrt the
* edge, are made orthogonal to the edge vector U. Division of
* the dot products is required to obtain the true projection
* ratios since U does not have unit length.
*/
du = v_dot(d, u);
eu = v_dot(e, u);
uu = v_dot(u, u);
v_mad(P, d, u, -du / uu);
/* First, test for intersection. */
if (v_dot(P, P) < r * r)
{
/* The sphere already intersects the line of the edge. */
if (du < 0 || du > uu)
{
/*
* The sphere is behind the endpoints of the edge, and
* can't hit the edge without hitting the vertices first.
*/
return LARGE;
}
/* The sphere already intersects the edge. */
if (v_dot(P, e) >= 0)
{
/* Moving apart. */
return LARGE;
}
v_nrm(P, P);
v_mad(Q, p, P, -r);
return 0;
}
v_mad(V, e, u, -eu / uu);
t = v_sol(P, V, r);
s = (du + eu * t) / uu; /* Projection of D + E * t on U. */
if (0.0f <= t && t < LARGE && 0.0f < s && s < 1.0f)
{
v_mad(d, o, w, t);
v_mad(e, q, u, s);
v_add(Q, e, d);
}
else
t = LARGE;
return t;
}
/*
* Compute the earliest time and position of the intersection of a
* sphere and a plane.
*
* The sphere has radius R and moves along vector V from point P. The
* plane moves along vector W. The plane has normal N and is
* positioned at distance D from the origin O along that normal.
*/
static float v_side(float Q[3],
const float o[3],
const float w[3],
const float n[3], float d,
const float p[3],
const float v[3], float r)
{
float vn = v_dot(v, n);
float wn = v_dot(w, n);
float t = LARGE;
if (vn - wn <= 0.0f)
{
float on = v_dot(o, n);
float pn = v_dot(p, n);
float u = (r + d + on - pn) / (vn - wn);
float a = ( d + on - pn) / (vn - wn);
if (0.0f <= u)
{
t = u;
v_mad(Q, p, v, +t);
v_mad(Q, Q, n, -r);
}
else if (0.0f <= a)
{
t = 0;
v_mad(Q, p, v, +t);
v_mad(Q, Q, n, -r);
}
}
return t;
}
/*---------------------------------------------------------------------------*/
/*
* Compute the new linear and angular velocities of a bouncing ball.
* Q gives the position of the point of impact and W gives the
* velocity of the object being impacted.
*/
static float sol_bounce(struct v_ball *up,
const float q[3],
const float w[3], float dt)
{
float n[3], r[3], d[3], vn, wn;
float *p = up->p;
float *v = up->v;
/* Find the normal of the impact. */
v_sub(r, p, q);
v_sub(d, v, w);
v_nrm(n, r);
/* Find the new angular velocity. */
v_crs(up->w, d, r);
v_scl(up->w, up->w, -1.0f / (up->r * up->r));
/* Find the new linear velocity. */
vn = v_dot(v, n);
wn = v_dot(w, n);
v_mad(v, v, n, 1.7 * (wn - vn));
v_mad(p, q, n, up->r);
/* Return the "energy" of the impact, to determine the sound amplitude. */
return fabsf(v_dot(n, d));
}
/*---------------------------------------------------------------------------*/
static float sol_test_vert(float dt,
float T[3],
const struct v_ball *up,
const struct b_vert *vp,
const float o[3],
const float w[3])
{
return v_vert(T, o, vp->p, w, up->p, up->v, up->r);
}
static float sol_test_edge(float dt,
float T[3],
const struct v_ball *up,
const struct s_base *base,
const struct b_edge *ep,
const float o[3],
const float w[3])
{
float q[3];
float u[3];
v_cpy(q, base->vv[ep->vi].p);
v_sub(u, base->vv[ep->vj].p, base->vv[ep->vi].p);
return v_edge(T, o, q, u, w, up->p, up->v, up->r);
}
static float sol_test_side(float dt,
float T[3],
const struct v_ball *up,
const struct s_base *base,
const struct b_lump *lp,
const struct b_side *sp,
const float o[3],
const float w[3])
{
float t = v_side(T, o, w, sp->n, sp->d, up->p, up->v, up->r);
int i;
if (t < dt)
for (i = 0; i < lp->sc; i++)
{
const struct b_side *sq = base->sv + base->iv[lp->s0 + i];
if (sp != sq &&
v_dot(T, sq->n) -
v_dot(o, sq->n) -
v_dot(w, sq->n) * t > sq->d)
return LARGE;
}
return t;
}
/*---------------------------------------------------------------------------*/
static int sol_test_fore(float dt,
const struct v_ball *up,
const struct b_side *sp,
const float o[3],
const float w[3])
{
float q[3], d;
/* If the ball is not behind the plane, the test passes. */
v_sub(q, up->p, o);
d = sp->d;
if (v_dot(q, sp->n) - d + up->r >= 0)
return 1;
/* If it's not behind the plane after DT seconds, the test passes. */
v_mad(q, q, up->v, dt);
d += v_dot(w, sp->n) * dt;
if (v_dot(q, sp->n) - d + up->r >= 0)
return 1;
/* Else, test fails. */
return 0;
}
static int sol_test_back(float dt,
const struct v_ball *up,
const struct b_side *sp,
const float o[3],
const float w[3])
{
float q[3], d;
/* If the ball is not in front of the plane, the test passes. */
v_sub(q, up->p, o);
d = sp->d;
if (v_dot(q, sp->n) - d - up->r <= 0)
return 1;
/* If it's not in front of the plane after DT seconds, the test passes. */
v_mad(q, q, up->v, dt);
d += v_dot(w, sp->n) * dt;
if (v_dot(q, sp->n) - d - up->r <= 0)
return 1;
/* Else, test fails. */
return 0;
}
/*---------------------------------------------------------------------------*/
static float sol_test_lump(float dt,
float T[3],
const struct v_ball *up,
const struct s_base *base,
const struct b_lump *lp,
const float o[3],
const float w[3])
{
float U[3] = { 0.0f, 0.0f, 0.0f };
float u, t = dt;
int i;
/* Short circuit a non-solid lump. */
if (lp->fl & L_DETAIL) return t;
/* Test all verts */
if (up->r > 0.0f)
for (i = 0; i < lp->vc; i++)
{
const struct b_vert *vp = base->vv + base->iv[lp->v0 + i];
if ((u = sol_test_vert(t, U, up, vp, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
/* Test all edges */
if (up->r > 0.0f)
for (i = 0; i < lp->ec; i++)
{
const struct b_edge *ep = base->ev + base->iv[lp->e0 + i];
if ((u = sol_test_edge(t, U, up, base, ep, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
/* Test all sides */
for (i = 0; i < lp->sc; i++)
{
const struct b_side *sp = base->sv + base->iv[lp->s0 + i];
if ((u = sol_test_side(t, U, up, base, lp, sp, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
return t;
}
static float sol_test_node(float dt,
float T[3],
const struct v_ball *up,
const struct s_base *base,
const struct b_node *np,
const float o[3],
const float w[3])
{
float U[3], u, t = dt;
int i;
/* Test all lumps */
for (i = 0; i < np->lc; i++)
{
const struct b_lump *lp = base->lv + np->l0 + i;
if ((u = sol_test_lump(t, U, up, base, lp, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
/* Test in front of this node */
if (np->ni >= 0 && sol_test_fore(t, up, base->sv + np->si, o, w))
{
const struct b_node *nq = base->nv + np->ni;
if ((u = sol_test_node(t, U, up, base, nq, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
/* Test behind this node */
if (np->nj >= 0 && sol_test_back(t, up, base->sv + np->si, o, w))
{
const struct b_node *nq = base->nv + np->nj;
if ((u = sol_test_node(t, U, up, base, nq, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
return t;
}
static float sol_test_body(float dt,
float T[3], float V[3],
const struct v_ball *up,
const struct s_vary *vary,
const struct v_body *bp)
{
float U[3], O[3], E[4], W[3], u;
const struct b_node *np = vary->base->nv + bp->base->ni;
sol_body_p(O, vary, bp, 0.0f);
sol_body_v(W, vary, bp, dt);
sol_body_e(E, vary, bp, 0.0f);
/*
* For rotating bodies, rather than rotate every normal and vertex
* of the body, we temporarily pretend the ball is rotating and
* moving about a static body.
*/
/*
* Linear velocity of a point rotating about the origin:
* v = w x p
*/
if (E[0] != 1.0f || sol_body_w(vary, bp))
{
/* The body has a non-identity orientation or it is rotating. */
struct v_ball ball;
float e[4], p0[3], p1[3];
const float z[3] = { 0 };
/* First, calculate position at start and end of time interval. */
v_sub(p0, up->p, O);
v_cpy(p1, p0);
q_conj(e, E);
q_rot(p0, e, p0);
v_mad(p1, p1, up->v, dt);
v_mad(p1, p1, W, -dt);
sol_body_e(e, vary, bp, dt);
q_conj(e, e);
q_rot(p1, e, p1);
/* Set up ball struct with values relative to body. */
ball = *up;
v_cpy(ball.p, p0);
/* Calculate velocity from start/end positions and time. */
v_sub(ball.v, p1, p0);
v_scl(ball.v, ball.v, 1.0f / dt);
if ((u = sol_test_node(dt, U, &ball, vary->base, np, z, z)) < dt)
{
/* Compute the final orientation. */
sol_body_e(e, vary, bp, u);
/* Return world space coordinates. */
q_rot(T, e, U);
v_add(T, O, T);
/* Move forward. */
v_mad(T, T, W, u);
/* Express "non-ball" velocity. */
q_rot(V, e, ball.v);
v_sub(V, up->v, V);
dt = u;
}
}
else
{
if ((u = sol_test_node(dt, U, up, vary->base, np, O, W)) < dt)
{
v_cpy(T, U);
v_cpy(V, W);
dt = u;
}
}
return dt;
}
static float sol_test_file(float dt,
float T[3], float V[3],
const struct v_ball *up,
const struct s_vary *vary)
{
float U[3], W[3], u, t = dt;
int i;
for (i = 0; i < vary->bc; i++)
{
const struct v_body *bp = vary->bv + i;
if ((u = sol_test_body(t, U, W, up, vary, bp)) < t)
{
v_cpy(T, U);
v_cpy(V, W);
t = u;
}
}
return t;
}
/*---------------------------------------------------------------------------*/
/*
* Track simulation steps in integer milliseconds.
*/
static float ms_accum;
static void ms_init(void)
{
ms_accum = 0.0f;
}
static int ms_step(float dt)
{
int ms = 0;
ms_accum += dt;
while (ms_accum >= 0.001f)
{
ms_accum -= 0.001f;
ms += 1;
}
return ms;
}
static int ms_peek(float dt)
{
int ms = 0;
float at;
at = ms_accum + dt;
while (at >= 0.001f)
{
at -= 0.001f;
ms += 1;
}
return ms;
}
/*---------------------------------------------------------------------------*/
/*
* Step the physics forward DT seconds under the influence of gravity
* vector G. If the ball gets pinched between two moving solids, this
* loop might not terminate. It is better to do something physically
* impossible than to lock up the game. So, if we make more than C
* iterations, punt it.
*/
float sol_step(struct s_vary *vary, const float *g, float dt, int ui, int *m)
{
float P[3], V[3], v[3], r[3], a[3], d, e, nt, b = 0.0f, tt = dt;
int c;
union cmd cmd;
if (ui < vary->uc)
{
struct v_ball *up = vary->uv + ui;
/* If the ball is in contact with a surface, apply friction. */
v_cpy(a, up->v);
v_cpy(v, up->v);
v_cpy(up->v, g);
if (m && sol_test_file(tt, P, V, up, vary) < 0.0005f)
{
v_cpy(up->v, v);
v_sub(r, P, up->p);
if ((d = v_dot(r, g) / (v_len(r) * v_len(g))) > 0.999f)
{
if ((e = (v_len(up->v) - dt)) > 0.0f)
{
/* Scale the linear velocity. */
v_nrm(up->v, up->v);
v_scl(up->v, up->v, e);
/* Scale the angular velocity. */
v_sub(v, V, up->v);
v_crs(up->w, v, r);
v_scl(up->w, up->w, -1.0f / (up->r * up->r));
}
else
{
/* Friction has brought the ball to a stop. */
up->v[0] = 0.0f;
up->v[1] = 0.0f;
up->v[2] = 0.0f;
(*m)++;
}
}
else v_mad(up->v, v, g, tt);
}
else v_mad(up->v, v, g, tt);
/* Test for collision. */
for (c = 16; c > 0 && tt > 0; c--)
{
float st;
int mi, ms;
/* HACK: avoid stepping across path changes. */
st = tt;
for (mi = 0; mi < vary->mc; mi++)
{
struct v_move *mp = vary->mv + mi;
struct v_path *pp = vary->pv + mp->pi;
if (!pp->f)
continue;
if (mp->tm + ms_peek(st) > pp->base->tm)
st = MS_TO_TIME(pp->base->tm - mp->tm);
}
/* Miss collisions if we reach the iteration limit. */
if (c > 1)
nt = sol_test_file(st, P, V, up, vary);
else
nt = tt;
cmd.type = CMD_STEP_SIMULATION;
cmd.stepsim.dt = nt;
sol_cmd_enq(&cmd);
ms = ms_step(nt);
sol_move_step(vary, nt, ms);
sol_swch_step(vary, nt, ms);
sol_ball_step(vary, nt);
if (nt < st)
if (b < (d = sol_bounce(up, P, V, nt)))
b = d;
tt -= nt;
}
v_sub(a, up->v, a);
sol_pendulum(up, a, g, dt);
}
return b;
}
/*---------------------------------------------------------------------------*/
void sol_init_sim(struct s_vary *vary)
{
ms_init();
}
void sol_quit_sim(void)
{
return;
}
/*---------------------------------------------------------------------------*/
| Java |
/*
* PS3 Media Server, for streaming any medias to your PS3.
* Copyright (C) 2012 Ph.Waeber
*
* 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; version 2
* of the License only.
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package net.pms.medialibrary.commons.dataobjects;
import net.pms.medialibrary.commons.enumarations.ThumbnailPrioType;
public class DOThumbnailPriority {
private long id;
private ThumbnailPrioType thumbnailPriorityType;
private String picturePath;
private int seekPosition;
private int priorityIndex;
public DOThumbnailPriority(){
this(-1, ThumbnailPrioType.THUMBNAIL, "", 0);
}
public DOThumbnailPriority(long id, ThumbnailPrioType thumbnailPriorityType, String picturePath, int priorityIndex){
this(id, thumbnailPriorityType, -1, picturePath, priorityIndex);
}
public DOThumbnailPriority(long id, ThumbnailPrioType thumbnailPriorityType, int seekPosition, int priorityIndex){
this(id, thumbnailPriorityType, seekPosition, "", priorityIndex);
}
public DOThumbnailPriority(long id, ThumbnailPrioType thumbnailPriorityType, int seekPosition, String picturePath, int priorityIndex){
setId(id);
setThumbnailPriorityType(thumbnailPriorityType);
setSeekPosition(seekPosition);
setPicturePath(picturePath);
setPriorityIndex(priorityIndex);
}
public void setThumbnailPriorityType(ThumbnailPrioType thumbnailPriorityType) {
this.thumbnailPriorityType = thumbnailPriorityType;
}
public ThumbnailPrioType getThumbnailPriorityType() {
return thumbnailPriorityType;
}
public void setPicturePath(String picturePath) {
this.picturePath = picturePath;
}
public String getPicturePath() {
return picturePath;
}
public void setSeekPosition(int seekPosition) {
this.seekPosition = seekPosition;
}
public int getSeekPosition() {
return seekPosition;
}
public void setPriorityIndex(int priorityIndex) {
this.priorityIndex = priorityIndex;
}
public int getPriorityIndex() {
return priorityIndex;
}
public void setId(long id) {
this.id = id;
}
public long getId() {
return id;
}
@Override
public boolean equals(Object obj){
if(!(obj instanceof DOThumbnailPriority)){
return false;
}
DOThumbnailPriority compObj = (DOThumbnailPriority) obj;
if(getId() == compObj.getId()
&& getThumbnailPriorityType() == compObj.getThumbnailPriorityType()
&& getPicturePath().equals(compObj.getPicturePath())
&& getSeekPosition() == compObj.getSeekPosition()
&& getPriorityIndex() == compObj.getPriorityIndex()){
return true;
}
return false;
}
@Override
public int hashCode(){
int hashCode = 24 + String.valueOf(getId()).hashCode();
hashCode *= 24 + getPicturePath().hashCode();
hashCode *= 24 + getSeekPosition();
hashCode *= 24 + getPriorityIndex();
return hashCode;
}
@Override
public DOThumbnailPriority clone(){
return new DOThumbnailPriority(getId(), getThumbnailPriorityType(), getSeekPosition(), getPicturePath(), getPriorityIndex());
}
@Override
public String toString(){
return String.format("id=%s, prioIndex=%s, type=%s, seekPos=%s, picPath=%s", getId(), getPriorityIndex(), getThumbnailPriorityType(), getSeekPosition(), getPicturePath());
}
}
| Java |
/*
* This file is part of ePipe
* Copyright (C) 2019, Logical Clocks AB. All rights reserved
*
* 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-1307, USA.
*/
#ifndef TBLSTAILER_H
#define TBLSTAILER_H
#include "TableTailer.h"
#include "tables/hive/TBLSTable.h"
#include "tables/hive/SDSTable.h"
#include "tables/hive/TABCOLSTATSTable.h"
#include "tables/hive/TABLEPARAMSTable.h"
class TBLSTailer : public TableTailer<TBLSRow> {
public:
TBLSTailer(Ndb *ndb, const int poll_maxTimeToWait, const Barrier barrier)
: TableTailer(ndb, new TBLSTable(), poll_maxTimeToWait, barrier) {}
virtual ~TBLSTailer() {}
private:
SDSTable mSDSTable;
TABLEPARAMSTable mTABLEPARAMSTable;
TABCOLSTATSTable mTABCOLSTATSTable;
virtual void handleEvent(NdbDictionary::Event::TableEvent eventType, TBLSRow
pre, TBLSRow row) {
LOG_INFO("Delete TBLS event received. Primary Key value: " << pre.mTBLID);
mTABLEPARAMSTable.remove(mNdbConnection, pre.mTBLID);
mTABCOLSTATSTable.remove(mNdbConnection, pre.mTBLID);
mSDSTable.remove(mNdbConnection, pre.mSDID);
}
};
#endif /* TBLSTAILER_H */
| Java |
#!/bin/sh
# Copyright (C) 1999-2005 ImageMagick Studio LLC
#
# This program is covered by multiple licenses, which are described in
# LICENSE. You should have received a copy of LICENSE with this
# package; otherwise see http://www.imagemagick.org/script/license.php.
. ${srcdir}/tests/common.shi
${RUNENV} ${MEMCHECK} ./rwfile ${SRCDIR}/input_truecolor16.dpx PPM
| Java |
package cmd
import (
"github.com/spf13/cobra"
)
// rotateCmd represents the shuffletips command
var rotateCmd = &cobra.Command{
Use: "rotate",
Short: "Rotates children of internal nodes",
Long: `Rotates children of internal nodes by different means.
Either randomly with "rand" subcommand, either sorting by number of tips
with "sort" subcommand.
It does not change the topology, but just the order of neighbors
of all node and thus the newick representation.
------C ------A
x |z x |z
A---------*ROOT => B---------*ROOT
|t |t
------B ------C
Example of usage:
gotree rotate rand -i t.nw
gotree rotate sort -i t.nw
`,
}
func init() {
RootCmd.AddCommand(rotateCmd)
rotateCmd.PersistentFlags().StringVarP(&intreefile, "input", "i", "stdin", "Input tree")
rotateCmd.PersistentFlags().StringVarP(&outtreefile, "output", "o", "stdout", "Rotated tree output file")
}
| Java |
/*
* Copyright 2015 AASHTO/ITE/NEMA.
* American Association of State Highway and Transportation Officials,
* Institute of Transportation Engineers and
* National Electrical Manufacturers Association.
*
* This file is part of the Advanced Transportation Controller (ATC)
* Application Programming Interface Validation Suite (APIVS).
*
* The APIVS 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.
*
* The APIVS 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 the APIVS. If not, see <http://www.gnu.org/licenses/>.
*/
/*****************************************************************************
* \file emfio_setupCommands.h
*
* (c) Copyright 2010 ITE
* All rights reserved. Copying or other reproduction of this program
* except for archival purposes is prohibited without the prior written
* consent of ITE.
*
* \brief This file declares the functions that setup and teardown the command structures.
*
* \date 12/22/2010
*
* \author Steve Kapp
*
* \version 1.0
*****************************************************************************/
#ifndef emfio_setupCommands_h
#define emfio_setupCommands_h
//=============================================================================
/**
* Includes
*/
#include <stdint.h> // STD IEEE Type Definitions - int16_t, uint8_t, etc.
//=============================================================================
/**
* External Global Routines
*/
extern int16_t emfio_setupCommands();
extern int16_t emfio_teardownCommands();
extern int16_t emfio_setupResponses();
extern int16_t emfio_teardownResponses();
extern uint32_t emfio_getNextLoadCounter();
extern uint32_t emfio_getNextReceiveCounter();
#endif
| Java |
<div class="header"><h1 class="slidetitle">Make the most of the web</h1></div>
<div class="main">
<div class="text">
<div>
<p>Ubuntu MATE includes Firefox, the web browser used by millions of people around the world. And web applications you use frequently (like Facebook or Gmail, for example) can be pinned to your desktop for faster access, just like apps on your computer.</p>
</div>
<div class="featured">
<h2 class="subtitle">Included software</h2>
<ul>
<li>
<img class="icon" src="icons/firefox.png" />
<p class="caption">Firefox web browser</p>
</li>
<li>
<img class="icon" src="icons/thunderbird.png" />
<p class="caption">Thunderbird Mail
</p>
</li>
</ul>
<h2 class="subtitle">Supported software</h2>
<ul>
<li>
<img class="icon" src="icons/chromium.png" />
<p class="caption">Chromium</p>
</li>
</ul>
</div>
</div>
<img class="screenshot" src="screenshots/06_browse.jpg" />
</div>
| Java |
<?php include_once('sites/all/themes/artonair/custom_functions/custom_variable.php'); /* mp3 folder path */ ?>
<?php include_once('sites/all/themes/artonair/custom_functions/default_image.php'); /* function for displaying default images */ ?>
<?php $listen_url = "/drupal/play/" . $node->nid . "/" . $node->path; ?>
<?php global $base_url;
$vgvr = views_get_view_result('archive_popular', 'default');
$node_status = "";
foreach($vgvr as $vresult) {
if($vresult->nid == $node->nid) $node_status = "Popular!";
}
?>
<div class="<?php print $node->type; ?>-body bodyview <?php
foreach($node->taxonomy as $term) {
$your_vocabulary_id = 108;
if ($term->vid == $your_vocabulary_id) {
print $term->name;
}
} ?>">
<div class="content-section">
<div class="left-column" id="header-info">
<div class="header">
<div class="info">
<?php // if($node->field_series[0]['view']) { ?>
<!-- <h6 class="type">
<span><?php// print l("Radio Show", "radio"); ?></span>ABC</h6>
<h6 class="dates"><?php //print $node->field_series[0]['view']; ?></h6>-->
<?php // } ?>
<?php // if($node->type == "series") { ?>
<!-- <span><?php // print l("Radio Series", "radio/series"); ?></span><?php $view = views_get_view('series_contents');
$args = array($node->nid);
$view->set_display('default', $args); // like 'block_1'
$view->render(); ?>
<div class="episode-count"><?php // print sizeof($view->result);?> Episodes</div>
<?php // } ?> -->
<?php // if($node->type == "news") { ?>
<!-- <span><?php // print l("Radio", "radio"); ?></span>Featured Shows This Week -->
<?php // } ?>
<?php if($node->type == "blog") { ?>
<h6 class="type"><span><?php print l("News", "news"); ?></span></h6>
<h6 class="dates"> <?php
foreach($node->taxonomy as $term) {
$your_vocabulary_id = 108;
if ($term->vid == $your_vocabulary_id) {
print $term->name;
}
} ?></h6>
<?php } ?>
<?php if($node->type == "host") { ?>
<span><?php print l("People", "radio/hosts"); ?></span><?php $view = views_get_view('series_contents');
$args = array($node->nid);
$view->set_display('default', $args); // like 'block_1'
$view->render(); ?>
<div class="episode-count"><?php print sizeof($view->result);?> Programs</div>
<?php } ?>
</h6><!-- /.type -->
<?php if($node->type != "news") { ?>
<div class="title">
<h1><?php print $node->title; ?></h1>
</div><!-- /.title -->
<?php } ?>
<?php if($node->field_host[0]['view']) { ?>
<h6 class="hosts">
Hosted by <?php $hostno = 0; foreach ($node->field_host as $one_host) { ?>
<?php if($hostno > 0) print "<span class='comma'>,</a>"; ?>
<span class="host"><?php print $one_host['view']; ?></span>
<?php $hostno++; } ?>
</h6>
<?php } ?>
<?php if(!empty($node->field_host_type[0]['view'])) { ?>
<h6 class="host-types">
<?php $hosttypesno = 0; foreach ($node->field_host_type as $one_host_type) { ?>
<?php if($hosttypesno > 0) print "<span class='comma'>,</a>"; ?>
<span class="host-type"><?php print $one_host_type['view']; ?></span>
<?php $hosttypesno++; } ?>
</h6>
<?php } ?>
</div> <!-- /.info -->
</div><!-- /.header -->
</div> <!-- left-column -->
<?php if($node->type != "news") { ?>
<?php if($node->field_image[0]['view']) { ?>
<div class="right-column">
<div class="header-image">
<div class="image"><?php print $node->field_image[0]['view']; ?> </div>
<div class="image-description"><?php print $node->field_image[0]['data']['description']; ?> </div>
</div><!-- /.header-image -->
</div><!-- /.right-column -->
<div class="left-column" id="node-content">
<?php } else { ?>
<div class="single-column" id="node-content">
<?php } ?>
<?php } ?>
<!--<div class="left-column" id="node-content">-->
<?php if ($node->taxonomy[13701]) { ?>
<?php if($node->field_media_embed[0]['view']) { ?>
<div class="video"><?php print $node->field_media_embed[0]['view']; ?></div>
<?php } ?>
<?php } ?>
<?php if($node->type == "series") { ?>
<?php print views_embed_view('also_in_this_series', 'series_listen', $node->nid); ?>
<!-- <div class="plus-button"><?php // print $_COOKIE["air-playlist"]; ?></div>-->
<?php } ?>
<?php if($node->type != "news") { ?>
<div class="share listen">
<?php if($node->field_audio_path[0]['safe']) { ?>
<div class="play">
<div class="listen-button">
<a href="<?php print $listen_url; ?>" onclick="popUpAIR(this.href,'fixed', 440, 570); return false;" target="artonair_music_popup"><img src="<?php print $base_url; ?>/sites/all/themes/artonair/images/triangle-white.png"></a>
</div>
<div class="listen-text"><a href="<?php print $listen_url; ?>" onclick="popUpAIR(this.href,'fixed', 440, 570); return false;" target="artonair_music_popup">Listen</a>
</div> <!-- /.listen-button -->
</div><!-- /.listen -->
<div class="plus-button"><?php print $_COOKIE["air-playlist"]; ?></div>
<?php } ?>
<div class="social">
<div class="addthis_toolbox addthis_default_style facebook"><a class="addthis_button_facebook_like" fb:like:layout="button_count"></a></div>
<script type="text/javascript" src="//s7.addthis.com/js/300/addthis_widget.js#pubid=xa-520a6a3258c56e49"></script>
<div class="twitter">
<a href="https://twitter.com/share" class="twitter-share-button" data-via="clocktower_nyc">Tweet</a>
<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>
</div><!-- /.twitter -->
</div> <!-- /.social -->
</div><!-- /.share .listen -->
<div class="content">
<?php print $node->content['body']['#value']; ?>
<?php if($node->field_long_description[0]['view']) { ?>
<?php print $node->field_long_description[0]['view']; ?>
<?php } ?>
<div class="content-foot">
<?php if($node->field_support[0]['view']) { ?>
<em><?php print $node->field_support[0]['view']; ?></em>
<?php } ?>
<?php if($node->type == "blog") { ?>
<h6 class="dates">Posted <?php print format_date($created, 'custom', 'F d, Y')?></h6>
<?php } ?>
<?php if($node->type == "show") { ?>
<?php if($node->field_aired_date[0]['view']) { ?>
<h6 class="aired_date">Originally aired <span class="aired_date_itself"><?php print $node->field_aired_date[0]['view']; ?></span></h6>
<?php } ?>
<div class="tags">
<h6 class="category"><?php print views_embed_view("radio_categories", "radio_tags", $node->nid); ?></h6>
</div>
<?php } ?>
<?php if($node->type == "series") { ?>
<h6 class="aired_date"><?php print views_embed_view('also_in_this_series', 'series_updated', $node->nid); ?></h6>
<div class="tags">
<h6 class="category"><?php print views_embed_view("radio_categories", "radio_tags", $node->nid); ?></h6>
</div>
<?php } ?>
<?php } ?>
<?php if($node->type == "blog") { ?>
<div class="tags">
<h6 class="category"><?php print views_embed_view("radio_categories", "radio_tags", $node->nid); ?></h6>
</div>
<?php } ?>
</div><!-- /.content-foot -->
</div><!-- /.content -->
</div><!-- /.left-column -->
<div class="right-column">
<div class="image-gallery">
<?php if($node->field_image[12]['view']) { ?>
<div class="thumbnails three">
<?php print views_embed_view('exhibition_thumbnails_slider', 'default', $node->nid); ?>
</div>
<?php
} else { ?>
<?php if($node->field_image[1]['view']) { ?>
<div class="thumbnails">
<?php print views_embed_view('exhibition_thumbnails_slider', 'default', $node->nid); ?>
</div>
<?php } ?>
<?php } ?>
</div><!-- /.image-gallery -->
</div><!-- /.right-column -->
</div><!-- /.bodyview -->
<?php if($node->type == "news") { ?>
<div class="in_this_news masonry">
<div class="news-body">
<?php print views_embed_view("new_this_week", "front_news_text", $node->nid); ?>
</div>
<div class="featured_projects" style="display:none;visibility:hidden;">
<?php print views_embed_view("in_this_news", "default", $node->nid); ?>
</div>
<div class="featured_radio" style="display:none;visibility:hidden;">
<?php print views_embed_view("in_this_news", "featured_radio", $node->nid); ?>
</div>
<div class="soundcloud item">
<?php $block = (object) module_invoke('block', 'block', 'view', "60");
print theme('block',$block); ?>
</div>
<div class="subscribe item">
<?php $block = (object) module_invoke('block', 'block', 'view', "42");
print theme('block',$block); ?>
</div>
</div><!-- /.in-this-news -->
<?php } ?>
<?php if($node->type != "news") { ?>
<?php $tags_display = views_embed_view('tags_for_node', 'default', $node->nid); ?>
<?php } ?>
<?php if($node->type == "blog") { ?>
<div class="also-list related">
<?php print views_embed_view('clocktower_related_radio', 'related_to_event', $node->nid); ?>
</div> <!-- also-list -->
<?php } ?>
<?php if($node->type == "show" && $node->field_series[0]['view']) { ?>
<div class="also-list masonry">
<div class="title item">
<h6>Other Episodes From</h6>
<h1><?php print $node->field_series[0]['view']; ?></h1>
</div>
<div class="series-contents">
<?php print views_embed_view('also_in_this_series', 'grid_related_shows', $node->field_series[0]['nid'], $node->nid); ?>
</div>
</div><!-- also-list -->
<div class="also-list">
<div class="block block-staffpicks">
<?php
$view = views_get_view('staffpicks');
print $view->preview('block_2');
?>
</div><!-- block-staffpicks -->
<div class="block block-popular">
<?php
$view = views_get_view('most_viewed_sidebar');
print $view->preview('block_2');
?>
</div><!-- block-popular -->
</div><!-- also-list -->
<?php } ?>
<?php if($node->type == "series") { ?>
<div class="also-list masonry">
<div class="series-contents">
<?php print views_embed_view('series_contents', 'grid_related_shows', $node->nid); ?>
</div>
</div><!-- also-list -->
<?php } ?>
<?php if($node->type == "host") { ?>
<div class="also-list masonry">
<div class="title item"><h1>Radio Featuring <?php print $node->title; ?></h1></div>
<div class="by-this-host-browse smallgrid listview gridlist-choice-apply"> <!-- the gridlist choice applies to this div -->
<?php print views_embed_view('by_this_host', 'of_this_host', $node->nid); ?>
<?php print views_embed_view('by_this_host', 'block_2', $node->nid); ?>
</div>
</div>
<?php } ?>
</div>
<!-- for addthis analytics -->
<div id="nid-for-javascript" style="display:none;"><?php print $node->nid; ?></div>
| Java |
/*
* (C) Copyright 2008-2013 STMicroelectronics.
*
* Sean McGoogan <Sean.McGoogan@st.com>
*
* See file CREDITS for list of people who contributed to this
* project.
*
* 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-1307 USA
*/
#include <common.h>
#include <command.h>
#include <asm/soc.h>
#include <asm/socregs.h>
#include <asm/io.h>
#include <asm/pio.h>
void flashWriteEnable(void)
{
/* Enable Vpp for writing to flash */
/* Nothing to do! */
}
void flashWriteDisable(void)
{
/* Disable Vpp for writing to flash */
/* Nothing to do! */
}
#if defined(CONFIG_ST40_STXH415)
#define PIOALT(port, pin, alt, dir) \
do \
{ \
stxh415_pioalt_select((port), (pin), (alt)); \
stxh415_pioalt_pad((port), (pin), (dir)); \
} while(0)
#elif defined(CONFIG_ST40_STXH416)
#define PIOALT(port, pin, alt, dir) \
do \
{ \
stxh416_pioalt_select((port), (pin), (alt)); \
stxh416_pioalt_pad((port), (pin), (dir)); \
} while(0)
#endif /* CONFIG_ST40_STXH415/CONFIG_ST40_STXH416 */
/*
* MII0: PIO106[2] = GMII0_notRESET
* MII0: PIO13[4] = PIO6_CLKSEL (DVO_CK)
*
* MII1: PIO4[7] = GMII1_notRESET (needs J39 fitted)
* MII1: PIO2[5] = PIO6_CLKSEL (PIO_HDMI_TX_HPD)
*/
#if CONFIG_SYS_STM_STMAC_BASE == CONFIG_SYS_STM_STMAC0_BASE /* MII0, on CN22 */
# define GMII_PHY_NOT_RESET 106, 2
# define GMII_PHY_CLKOUT_NOT_TXCLK_SEL 13, 4
#elif CONFIG_SYS_STM_STMAC_BASE == CONFIG_SYS_STM_STMAC1_BASE /* MII1, on CN23 */
# define GMII_PHY_NOT_RESET 4, 7
# define GMII_PHY_CLKOUT_NOT_TXCLK_SEL 2, 5
#endif
static void configPIO(void)
{
/* Setup PIOs for ASC device */
#if defined(CONFIG_ST40_STXH415)
#if CONFIG_SYS_STM_ASC_BASE == STXH415_ASC2_BASE
/* Route UART2 via PIO17 for TX, RX, CTS & RTS (Alternative #1) */
PIOALT(17, 4, 2, stm_pad_direction_output); /* UART2-TX */
PIOALT(17, 5, 2, stm_pad_direction_input); /* UART2-RX */
PIOALT(17, 7, 2, stm_pad_direction_output); /* UART2-RTS */
PIOALT(17, 6, 2, stm_pad_direction_input); /* UART2-CTS */
#elif CONFIG_SYS_STM_ASC_BASE == STXH415_SBC_ASC0_BASE
/* Route SBC_UART0 via PIO3 for TX, RX, CTS & RTS (Alternative #1) */
PIOALT(3, 4, 1, stm_pad_direction_output); /* SBC_UART0-TX */
PIOALT(3, 5, 1, stm_pad_direction_input); /* SBC_UART0-RX */
PIOALT(3, 7, 1, stm_pad_direction_output); /* SBC_UART0-RTS */
PIOALT(3, 6, 1, stm_pad_direction_input); /* SBC_UART0-CTS */
#elif CONFIG_SYS_STM_ASC_BASE == STXH415_SBC_ASC1_BASE
/* Route SBC_UART1 via PIO2,3 for TX, RX, CTS & RTS (Alternative #3) */
PIOALT(2, 6, 3, stm_pad_direction_output); /* SBC_UART1-TX */
PIOALT(2, 7, 3, stm_pad_direction_input); /* SBC_UART1-RX */
PIOALT(3, 1, 3, stm_pad_direction_output); /* SBC_UART1-RTS */
PIOALT(3, 0, 3, stm_pad_direction_input); /* SBC_UART1-CTS */
#else
#error Unknown ASC port selected!
#endif /* CONFIG_SYS_STM_ASC_BASE == STXH415_ASCx_REGS_BASE */
#elif defined(CONFIG_ST40_STXH416)
#if CONFIG_SYS_STM_ASC_BASE == STXH416_ASC2_BASE
/* Route UART2 via PIO17 for TX, RX, CTS & RTS (Alternative #1) */
PIOALT(17, 4, 2, stm_pad_direction_output); /* UART2-TX */
PIOALT(17, 5, 2, stm_pad_direction_input); /* UART2-RX */
PIOALT(17, 7, 2, stm_pad_direction_output); /* UART2-RTS */
PIOALT(17, 6, 2, stm_pad_direction_input); /* UART2-CTS */
#elif CONFIG_SYS_STM_ASC_BASE == STXH416_SBC_ASC0_BASE
/* Route SBC_UART0 via PIO3 for TX, RX, CTS & RTS (Alternative #1) */
PIOALT(3, 4, 1, stm_pad_direction_output); /* SBC_UART0-TX */
PIOALT(3, 5, 1, stm_pad_direction_input); /* SBC_UART0-RX */
PIOALT(3, 7, 1, stm_pad_direction_output); /* SBC_UART0-RTS */
PIOALT(3, 6, 1, stm_pad_direction_input); /* SBC_UART0-CTS */
#elif CONFIG_SYS_STM_ASC_BASE == STXH416_SBC_ASC1_BASE
/* Route SBC_UART1 via PIO2,3 for TX, RX, CTS & RTS (Alternative #3) */
PIOALT(2, 6, 3, stm_pad_direction_output); /* SBC_UART1-TX */
PIOALT(2, 7, 3, stm_pad_direction_input); /* SBC_UART1-RX */
PIOALT(3, 1, 3, stm_pad_direction_output); /* SBC_UART1-RTS */
PIOALT(3, 0, 3, stm_pad_direction_input); /* SBC_UART1-CTS */
#else
#error Unknown ASC port selected!
#endif /* CONFIG_SYS_STM_ASC_BASE == STXH416_ASCx_REGS_BASE */
#endif /* CONFIG_ST40_STXH415/CONFIG_ST40_STXH416 */
#ifdef CONFIG_DRIVER_NET_STM_GMAC
/*
* Configure the Ethernet PHY Reset signal
*/
SET_PIO_PIN2(GMII_PHY_NOT_RESET, STPIO_OUT);
/*
* Configure the Ethernet PHY Mux PIO clock signal,
* as an output, which controls the speed of the MAC.
*/
SET_PIO_PIN2(GMII_PHY_CLKOUT_NOT_TXCLK_SEL, STPIO_OUT);
STPIO_SET_PIN2(GMII_PHY_CLKOUT_NOT_TXCLK_SEL, 1);
#endif /* CONFIG_DRIVER_NET_STM_GMAC */
}
#ifdef CONFIG_DRIVER_NET_STM_GMAC
extern void stmac_phy_reset(void)
{
/*
* Reset the Ethernet PHY.
*/
STPIO_SET_PIN2(GMII_PHY_NOT_RESET, 0);
udelay(10000); /* 10 ms */
STPIO_SET_PIN2(GMII_PHY_NOT_RESET, 1);
udelay(10000); /* 10 ms */
}
#endif /* CONFIG_DRIVER_NET_STM_GMAC */
#ifdef CONFIG_DRIVER_NET_STM_GMAC
extern void stmac_set_mac_speed(int speed)
{
/* Manage the MAC speed */
STPIO_SET_PIN2(GMII_PHY_CLKOUT_NOT_TXCLK_SEL,
(speed==1000)?1:0);
}
#endif /* CONFIG_DRIVER_NET_STM_GMAC */
extern int board_init(void)
{
configPIO();
#if 0 /* QQQ - TO IMPLEMENT */
#if defined(CONFIG_ST40_STM_SATA)
stx7105_configure_sata ();
#endif /* CONFIG_ST40_STM_SATA */
#endif /* QQQ - TO IMPLEMENT */
/*
* B2032A (MII) Ethernet card (*not* GMII)
* On B2000B board, to get GMAC0 working make sure that jumper
* on PIN 9-10 on CN35 and CN36 are removed.
*
*******************************************************************
*
* B2035A (RMII + MMC(on CN22)) Ethernet + MMC card
* B2035A board has IP101ALF PHY connected in RMII mode
* and an MMC card
* It is designed to be connected to GMAC0 (CN22) to get MMC working,
* however we can connect it to GMAC1 for RMII testing.
*
*******************************************************************
*
* Note: The following (default) configuration assumes we are using
* the B2032 daughter board, in MII mode (not GMII). To use other
* configurations, then please have a look in the STLinux kernel
* distribution source trees for: arch/sh/boards/mach-b2000/setup.c
*/
#ifdef CONFIG_DRIVER_NET_STM_GMAC
#if CONFIG_SYS_STM_STMAC_BASE == CONFIG_SYS_STM_STMAC0_BASE /* MII0, on CN22 */
# if defined(CONFIG_STMAC_IP1001) /* IC+ IP1001 (B2032) */
#if defined(CONFIG_ST40_STXH415)
stxh415_configure_ethernet(0, &(struct stxh415_ethernet_config) {
.mode = stxh415_ethernet_mode_mii,
.ext_clk = 1,
.phy_bus = 0, });
#elif defined(CONFIG_ST40_STXH416)
stxh416_configure_ethernet(0, &(struct stxh416_ethernet_config) {
.mode = stxh416_ethernet_mode_mii,
.ext_clk = 1,
.phy_bus = 0, });
#endif /* CONFIG_ST40_STXH415/CONFIG_ST40_STXH416 */
# elif defined(CONFIG_STMAC_IP101A) /* IC+ IP101A (B2035) */
#if defined(CONFIG_ST40_STXH415)
stxh415_configure_ethernet(0, &(struct stxh415_ethernet_config) {
.mode = stxh415_ethernet_mode_rmii,
.ext_clk = 0,
.phy_bus = 0, });
#elif defined(CONFIG_ST40_STXH416)
stxh416_configure_ethernet(0, &(struct stxh416_ethernet_config) {
.mode = stxh416_ethernet_mode_rmii,
.ext_clk = 0,
.phy_bus = 0, });
#endif /* CONFIG_ST40_STXH415/CONFIG_ST40_STXH416 */
# else
# error Unknown PHY type associated with STM GMAC #0
# endif /* CONFIG_STMAC_IP1001 || CONFIG_STMAC_IP101A */
#elif CONFIG_SYS_STM_STMAC_BASE == CONFIG_SYS_STM_STMAC1_BASE /* MII1, on CN23 */
# if defined(CONFIG_STMAC_IP1001) /* IC+ IP1001 (B2032) */
#if defined(CONFIG_ST40_STXH415)
stxh415_configure_ethernet(1, &(struct stxh415_ethernet_config) {
.mode = stxh415_ethernet_mode_mii,
.ext_clk = 1,
.phy_bus = 1, });
#elif defined(CONFIG_ST40_STXH416)
stxh416_configure_ethernet(1, &(struct stxh416_ethernet_config) {
.mode = stxh416_ethernet_mode_mii,
.ext_clk = 1,
.phy_bus = 1, });
#endif /* CONFIG_ST40_STXH415/CONFIG_ST40_STXH416 */
# elif defined(CONFIG_STMAC_IP101A) /* IC+ IP101A (B2035) */
#if defined(CONFIG_ST40_STXH415)
stxh415_configure_ethernet(1, &(struct stxh415_ethernet_config) {
.mode = stxh415_ethernet_mode_rmii,
.ext_clk = 0,
.phy_bus = 1, });
#elif defined(CONFIG_ST40_STXH416)
stxh416_configure_ethernet(1, &(struct stxh416_ethernet_config) {
.mode = stxh416_ethernet_mode_rmii,
.ext_clk = 0,
.phy_bus = 1, });
#endif /* CONFIG_ST40_STXH415/CONFIG_ST40_STXH416 */
# else
# error Unknown PHY type associated with STM GMAC #1
# endif /* CONFIG_STMAC_IP1001 || CONFIG_STMAC_IP101A */
#else
#error Unknown base address for the STM GMAC
#endif
/* Hard Reset the PHY -- do after we have configured the MAC */
stmac_phy_reset();
#endif /* CONFIG_DRIVER_NET_STM_GMAC */
#if defined(CONFIG_CMD_I2C)
#if defined(CONFIG_ST40_STXH415)
stxh415_configure_i2c();
#elif defined(CONFIG_ST40_STXH416)
stxh416_configure_i2c();
#endif /* CONFIG_ST40_STXH415/CONFIG_ST40_STXH416 */
#endif /* CONFIG_CMD_I2C */
return 0;
}
int checkboard (void)
{
printf ("\n\nBoard: B2000"
#if defined(CONFIG_ST40_STXH415)
"-STxH415"
#elif defined(CONFIG_ST40_STXH416)
"-STxH416"
#endif
#ifdef CONFIG_ST40_SE_MODE
" [32-bit mode]"
#else
" [29-bit mode]"
#endif
"\n");
#if defined(CONFIG_SOFT_SPI)
/*
* Configure for the SPI Serial Flash.
* Note: for CONFIG_SYS_BOOT_FROM_SPI + CONFIG_ENV_IS_IN_EEPROM, this
* needs to be done after env_init(), hence it is done
* here, and not in board_init().
*/
#if defined(CONFIG_ST40_STXH415)
stxh415_configure_spi();
#elif defined(CONFIG_ST40_STXH416)
stxh416_configure_spi();
#endif /* CONFIG_ST40_STXH415/CONFIG_ST40_STXH416 */
#endif /* CONFIG_SPI */
return 0;
}
| Java |
<?php get_header(); ?>
<div id="content" class="clearfix">
<div id="main" class="col620 clearfix" role="main">
<article id="post-0" class="post error404 not-found">
<header class="entry-header">
<h1 class="entry-title"><?php _e( 'Error 404 - Page Not Found', 'newschannel' ); ?></h1>
</header>
<div class="entry-content post_content">
<h4><?php _e( 'It seems we can’t find what you’re looking for. Perhaps searching, or one of the links below, can help.', 'newschannel' ); ?></h4>
<div style="margin-bottom: 25px"><?php get_search_form(); ?></div>
<?php the_widget( 'WP_Widget_Recent_Posts' ); ?>
<div class="widget">
<h2 class="widgettitle"><?php _e( 'Most Used Categories', 'newschannel' ); ?></h2>
<ul>
<?php wp_list_categories( array( 'orderby' => 'count', 'order' => 'DESC', 'show_count' => 1, 'title_li' => '', 'number' => 10 ) ); ?>
</ul>
</div>
<?php
/* translators: %1$s: smilie */
$archive_content = '<p>' . sprintf( __( 'Try looking in the monthly archives. %1$s', 'newschannel' ), convert_smilies( ':)' ) ) . '</p>';
the_widget( 'WP_Widget_Archives', 'dropdown=1', "after_title=</h2>$archive_content" );
?>
<?php the_widget( 'WP_Widget_Tag_Cloud' ); ?>
</div><!-- .entry-content -->
</article><!-- #post-0 -->
</div> <!-- end #main -->
<?php get_sidebar(); ?>
</div> <!-- end #content -->
<?php get_footer(); ?> | Java |
package scatterbox.utils;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.HashMap;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
public class ImportVanKasteren {
String dataFileName = "/Users/knoxs/Documents/datasets/kasterenDataset/kasterenSenseData.txt";
String annotationFileName = "/Users/knoxs/Documents/datasets/kasterenDataset/kasterenActData.txt";
File dataFile = new File(dataFileName);
File annotationFile = new File(annotationFileName);
BufferedReader dataFileReader;
BufferedReader annotationFileReader;
Connection conn = null;
String insertDataCommand = "insert into events (start_time, end_time, id, java_type) values (\"START\", \"END\", \"OBJECT\", \"scatterbox.event.KasterenEvent\")";
String insertAnnotationCommand = "insert into annotations (start_time, end_time, annotation) values (\"START\", \"END\", \"ANNOTATION\")";
HashMap<Integer, String> objects = new HashMap<Integer, String>();
HashMap<Integer, String> annotations = new HashMap<Integer, String>();
//String[] annotations = {"leavehouse", "usetoilet", "takeshower", "gotobed", "preparebreakfast", "preparedinner", "getdrink"};
/**
* Format of the sql timestamp. Allows easy conversion to date format
*/
final DateTimeFormatter dateTimeFormatter = DateTimeFormat
.forPattern("dd-MMM-yyyy HH:mm:ss");
public static void main(String[] args) throws FileNotFoundException {
ImportVanKasteren ivk = new ImportVanKasteren();
ivk.connectToDatabase();
ivk.dataFileReader = new BufferedReader(new InputStreamReader(
new DataInputStream(new FileInputStream(ivk.dataFileName))));
ivk.annotationFileReader = new BufferedReader(new InputStreamReader(
new DataInputStream(new FileInputStream(ivk.annotationFileName))));
ivk.setUpAnnotations();
ivk.setUpObjects();
ivk.getData();
ivk.getAnnotations();
}
private void getData() {
String line;
try {
while ((line = dataFileReader.readLine()) != null) {
String[] readingArray = line.split("\t");
DateTime startTime = dateTimeFormatter
.parseDateTime(readingArray[0]);
Timestamp startTimestamp = new Timestamp(startTime.getMillis());
DateTime endTime = dateTimeFormatter.parseDateTime(readingArray[1]);
Timestamp endTimestamp = new Timestamp(endTime.getMillis());
int id = Integer.parseInt(readingArray[2]);
//The reason for -1 is because, kasteren starts id names at 1, not 0, but the array starts at 0.
String object = objects.get(id);
insertStatement(insertDataCommand.replace("START",
startTimestamp.toString()).replace("END",
endTimestamp.toString()).replace("OBJECT", object));
}
} catch (Exception ioe) {
ioe.printStackTrace();
}
}
private void getAnnotations() {
String line;
try {
while ((line = annotationFileReader.readLine()) != null) {
String[] readingArray = line.split("\t");
DateTime startTime = dateTimeFormatter
.parseDateTime(readingArray[0]);
Timestamp startTimestamp = new Timestamp(startTime.getMillis());
DateTime endTime = dateTimeFormatter.parseDateTime(readingArray[1]);
Timestamp endTimestamp = new Timestamp(endTime.getMillis());
int id = Integer.parseInt(readingArray[2]);
//The reason for -1 is because, kasteren starts id names at 1, not 0, but the array starts at 0.
String annotation = annotations.get(id);
insertStatement(insertAnnotationCommand.replace("START",
startTimestamp.toString()).replace("END",
endTimestamp.toString()).replace("ANNOTATION", annotation));
}
} catch (Exception ioe) {
ioe.printStackTrace();
}
}
public boolean insertStatement(String an_sql_statement) {
System.out.println(an_sql_statement);
boolean success = false;
//System.out.println(an_sql_statement);
Statement statement;
try {
statement = conn.createStatement();
if (conn != null) {
success = statement.execute(an_sql_statement);
statement.close();
} else {
System.err.println("No database connection!!!");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return success;
}
public boolean connectToDatabase() {
boolean connected = false;
String userName = "root";
String password = "";
String url = "jdbc:mysql://localhost:3306/tvk";
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url, userName, password);
if (conn != null) {
connected = true;
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return connected;
}
private void setUpObjects() {
objects.put(1, "microwave");
objects.put(5, "halltoiletdoor");
objects.put(6, "hallbathroomdoor");
objects.put(7, "cupscupboard");
objects.put(8, "fridge");
objects.put(9, "platescupboard");
objects.put(12, "frontdoor");
objects.put(13, "dishwasher");
objects.put(14, "toiletflush");
objects.put(17, "freezer");
objects.put(18, "panscupboard");
objects.put(20, "washingmachine");
objects.put(23, "groceriescupboard");
objects.put(24, "hallbedroomdoor");
}
private void setUpAnnotations() {
annotations.put(1, "leavehouse");
annotations.put(4, "usetoilet");
annotations.put(5, "takeshower");
annotations.put(10, "gotobed");
annotations.put(13, "preparebreakfast");
annotations.put(15, "preparedinner");
annotations.put(17, "getdrink");
}
}
| Java |
<?php
/*
* @version $Id: preference.php 20129 2013-02-04 16:53:59Z moyo $
-------------------------------------------------------------------------
GLPI - Gestionnaire Libre de Parc Informatique
Copyright (C) 2003-2013 by the INDEPNET Development Team.
http://indepnet.net/ http://glpi-project.org
-------------------------------------------------------------------------
LICENSE
This file is part of GLPI.
GLPI 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.
GLPI 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 GLPI. If not, see <http://www.gnu.org/licenses/>.
--------------------------------------------------------------------------
*/
/** @file
* @brief
*/
include ('../inc/includes.php');
$user = new User();
// Manage lost password
if (isset($_GET['lostpassword'])) {
Html::nullHeader();
if (isset($_GET['password_forget_token'])) {
User::showPasswordForgetChangeForm($_GET['password_forget_token']);
} else {
User::showPasswordForgetRequestForm();
}
Html::nullFooter();
exit();
}
Session::checkLoginUser();
if (isset($_POST["update"])
&& ($_POST["id"] === Session::getLoginUserID())) {
$user->update($_POST);
Event::log($_POST["id"], "users", 5, "setup",
//TRANS: %s is the user login
sprintf(__('%s updates an item'), $_SESSION["glpiname"]));
Html::back();
} else {
if ($_SESSION["glpiactiveprofile"]["interface"] == "central") {
Html::header(Preference::getTypeName(1), $_SERVER['PHP_SELF'],'preference');
} else {
Html::helpHeader(Preference::getTypeName(1), $_SERVER['PHP_SELF']);
}
$pref = new Preference();
$pref->show();
if ($_SESSION["glpiactiveprofile"]["interface"] == "central") {
Html::footer();
} else {
Html::helpFooter();
}
}
?> | Java |
<?php
/**
* @package Joomla.Administrator
* @subpackage com_templates
*
* @copyright Copyright (C) 2005 - 2017 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE.txt
*/
defined('_JEXEC') or die;
// Include the component HTML helpers.
JHtml::addIncludePath(JPATH_COMPONENT . '/helpers/html');
JHtml::_('bootstrap.tooltip');
JHtml::_('behavior.formvalidator');
JHtml::_('behavior.keepalive');
JHtml::_('behavior.tabstate');
$input = JFactory::getApplication()->input;
// No access if not global SuperUser
if (!JFactory::getUser()->authorise('core.admin'))
{
JFactory::getApplication()->enqueueMessage(JText::_('JERROR_ALERTNOAUTHOR'), 'danger');
}
if ($this->type == 'image')
{
JHtml::_('script', 'vendor/cropperjs/cropper.min.js', array('version' => 'auto', 'relative' => true));
JHtml::_('stylesheet', 'vendor/cropperjs/cropper.min.css', array('version' => 'auto', 'relative' => true));
}
JFactory::getDocument()->addScriptDeclaration("
jQuery(document).ready(function($){
// Hide all the folder when the page loads
$('.folder ul, .component-folder ul').hide();
// Display the tree after loading
$('.directory-tree').removeClass('directory-tree');
// Show all the lists in the path of an open file
$('.show > ul').show();
// Stop the default action of anchor tag on a click event
$('.folder-url, .component-folder-url').click(function(event){
event.preventDefault();
});
// Prevent the click event from proliferating
$('.file, .component-file-url').bind('click',function(e){
e.stopPropagation();
});
// Toggle the child indented list on a click event
$('.folder, .component-folder').bind('click',function(e){
$(this).children('ul').toggle();
e.stopPropagation();
});
// New file tree
$('#fileModal .folder-url').bind('click',function(e){
$('.folder-url').removeClass('selected');
e.stopPropagation();
$('#fileModal input.address').val($(this).attr('data-id'));
$(this).addClass('selected');
});
// Folder manager tree
$('#folderModal .folder-url').bind('click',function(e){
$('.folder-url').removeClass('selected');
e.stopPropagation();
$('#folderModal input.address').val($(this).attr('data-id'));
$(this).addClass('selected');
});
var containerDiv = document.querySelector('.span3.tree-holder'),
treeContainer = containerDiv.querySelector('.nav.nav-list'),
liEls = treeContainer.querySelectorAll('.folder.show'),
filePathEl = document.querySelector('p.lead.hidden.path');
if(filePathEl)
var filePathTmp = document.querySelector('p.lead.hidden.path').innerText;
if(filePathTmp && filePathTmp.charAt( 0 ) === '/' ) {
filePathTmp = filePathTmp.slice( 1 );
filePathTmp = filePathTmp.split('/');
filePathTmp = filePathTmp[filePathTmp.length - 1];
var re = new RegExp( filePathTmp );
for (var i = 0, l = liEls.length; i < l; i++) {
liEls[i].querySelector('a').classList.add('active');
if (i === liEls.length - 1) {
var parentUl = liEls[i].querySelector('ul'),
allLi = parentUl.querySelectorAll('li');
for (var i = 0, l = allLi.length; i < l; i++) {
aEl = allLi[i].querySelector('a'),
spanEl = aEl.querySelector('span');
if (spanEl && re.test(spanEl.innerText)) {
aEl.classList.add('active');
}
}
}
}
}
});");
if ($this->type == 'image')
{
JFactory::getDocument()->addScriptDeclaration("
document.addEventListener('DOMContentLoaded', function() {
// Configuration for image cropping
var image = document.getElementById('image-crop');
var cropper = new Cropper(image, {
viewMode: 0,
scalable: true,
zoomable: true,
minCanvasWidth: " . $this->image['width'] . ",
minCanvasHeight: " . $this->image['height'] . ",
});
image.addEventListener('crop', function (e) {
document.getElementById('x').value = e.detail.x;
document.getElementById('y').value = e.detail.y;
document.getElementById('w').value = e.detail.width;
document.getElementById('h').value = e.detail.height;
});
// Function for clearing the coordinates
function clearCoords()
{
var inputs = querySelectorAll('#adminForm input');
for(i=0, l=inputs.length; l>i; i++) {
inputs[i].value = '';
};
}
});");
}
JFactory::getDocument()->addStyleDeclaration('
/* Styles for modals */
.selected {
background: #08c;
color: #fff;
}
.selected:hover {
background: #08c !important;
color: #fff;
}
.modal-body .column-left {
float: left; max-height: 70vh; overflow-y: auto;
}
.modal-body .column-right {
float: right;
}
@media (max-width: 767px) {
.modal-body .column-right {
float: left;
}
}
#deleteFolder {
margin: 0;
}
#image-crop {
max-width: 100% !important;
width: auto;
height: auto;
}
.directory-tree {
display: none;
}
.tree-holder {
overflow-x: auto;
}
');
if ($this->type == 'font')
{
JFactory::getDocument()->addStyleDeclaration(
"/* Styles for font preview */
@font-face
{
font-family: previewFont;
src: url('" . $this->font['address'] . "')
}
.font-preview{
font-family: previewFont !important;
}"
);
}
?>
<?php echo JHtml::_('bootstrap.startTabSet', 'myTab', array('active' => 'editor')); ?>
<?php echo JHtml::_('bootstrap.addTab', 'myTab', 'editor', JText::_('COM_TEMPLATES_TAB_EDITOR')); ?>
<div class="row">
<div class="col-md-12">
<?php if($this->type == 'file') : ?>
<p class="lead"><?php echo JText::sprintf('COM_TEMPLATES_TEMPLATE_FILENAME', $this->source->filename, $this->template->element); ?></p>
<p class="lead path hidden"><?php echo $this->source->filename; ?></p>
<?php endif; ?>
<?php if($this->type == 'image') : ?>
<p class="lead"><?php echo JText::sprintf('COM_TEMPLATES_TEMPLATE_FILENAME', $this->image['path'], $this->template->element); ?></p>
<p class="lead path hidden"><?php echo $this->image['path']; ?></p>
<?php endif; ?>
<?php if($this->type == 'font') : ?>
<p class="lead"><?php echo JText::sprintf('COM_TEMPLATES_TEMPLATE_FILENAME', $this->font['rel_path'], $this->template->element); ?></p>
<p class="lead path hidden"><?php echo $this->font['rel_path']; ?></p>
<?php endif; ?>
</div>
</div>
<div class="row">
<div class="col-md-3 tree-holder">
<?php echo $this->loadTemplate('tree'); ?>
</div>
<div class="col-md-9">
<?php if ($this->type == 'home') : ?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<input type="hidden" name="task" value="">
<?php echo JHtml::_('form.token'); ?>
<h2><?php echo JText::_('COM_TEMPLATES_HOME_HEADING'); ?></h2>
<p><?php echo JText::_('COM_TEMPLATES_HOME_TEXT'); ?></p>
<p>
<a href="https://docs.joomla.org/J3.x:How_to_use_the_Template_Manager" target="_blank" class="btn btn-primary btn-lg">
<?php echo JText::_('COM_TEMPLATES_HOME_BUTTON'); ?>
</a>
</p>
</form>
<?php endif; ?>
<?php if ($this->type == 'file') : ?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<div class="editor-border">
<?php echo $this->form->getInput('source'); ?>
</div>
<input type="hidden" name="task" value="" />
<?php echo JHtml::_('form.token'); ?>
<?php echo $this->form->getInput('extension_id'); ?>
<?php echo $this->form->getInput('filename'); ?>
</form>
<?php endif; ?>
<?php if ($this->type == 'archive') : ?>
<legend><?php echo JText::_('COM_TEMPLATES_FILE_CONTENT_PREVIEW'); ?></legend>
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<ul class="nav flex-column well">
<?php foreach ($this->archive as $file) : ?>
<li>
<?php if (substr($file, -1) === DIRECTORY_SEPARATOR) : ?>
<i class="fa-fw fa fa-folder"></i> <?php echo $file; ?>
<?php endif; ?>
<?php if (substr($file, -1) != DIRECTORY_SEPARATOR) : ?>
<i class="fa-fw fa fa-file-o"></i> <?php echo $file; ?>
<?php endif; ?>
</li>
<?php endforeach; ?>
</ul>
<input type="hidden" name="task" value="">
<?php echo JHtml::_('form.token'); ?>
</form>
<?php endif; ?>
<?php if ($this->type == 'image') : ?>
<img id="image-crop" src="<?php echo $this->image['address'] . '?' . time(); ?>">
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<fieldset class="adminform">
<input type ="hidden" id="x" name="x">
<input type ="hidden" id="y" name="y">
<input type ="hidden" id="h" name="h">
<input type ="hidden" id="w" name="w">
<input type="hidden" name="task" value="">
<?php echo JHtml::_('form.token'); ?>
</fieldset>
</form>
<?php endif; ?>
<?php if ($this->type == 'font') : ?>
<div class="font-preview">
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<fieldset class="adminform">
<h1>H1. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h1>
<h2>H2. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h2>
<h3>H3. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h3>
<h4>H4. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h4>
<h5>H5. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h5>
<h6>H6. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h6>
<p><b>Bold. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</b></p>
<p><i>Italics. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</i></p>
<p>Unordered List</p>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item<br>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item<br>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item</li>
</ul>
</li>
</ul>
</li>
</ul>
<p class="lead">Ordered List</p>
<ol>
<li>Item</li>
<li>Item</li>
<li>Item<br>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item<br>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item</li>
</ul>
</li>
</ul>
</li>
</ol>
<input type="hidden" name="task" value="">
<?php echo JHtml::_('form.token'); ?>
</fieldset>
</form>
</div>
<?php endif; ?>
</div>
</div>
<?php echo JHtml::_('bootstrap.endTab'); ?>
<?php echo JHtml::_('bootstrap.addTab', 'myTab', 'overrides', JText::_('COM_TEMPLATES_TAB_OVERRIDES')); ?>
<div class="row">
<div class="col-md-4">
<legend><?php echo JText::_('COM_TEMPLATES_OVERRIDES_MODULES'); ?></legend>
<ul class="list-unstyled">
<?php $token = JSession::getFormToken() . '=' . 1; ?>
<?php foreach ($this->overridesList['modules'] as $module) : ?>
<li>
<?php
$overrideLinkUrl = 'index.php?option=com_templates&view=template&task=template.overrides&folder=' . $module->path
. '&id=' . $input->getInt('id') . '&file=' . $this->file . '&' . $token;
?>
<a href="<?php echo JRoute::_($overrideLinkUrl); ?>">
<i class="fa fa-files-o"></i> <?php echo $module->name; ?>
</a>
</li>
<?php endforeach; ?>
</ul>
</div>
<div class="col-md-4">
<legend><?php echo JText::_('COM_TEMPLATES_OVERRIDES_COMPONENTS'); ?></legend>
<ul class="list-unstyled">
<?php $token = JSession::getFormToken() . '=' . 1; ?>
<?php foreach ($this->overridesList['components'] as $key => $value) : ?>
<li class="component-folder">
<a href="#" class="component-folder-url">
<i class="fa fa-folder"></i> <?php echo $key; ?>
</a>
<ul class="list-unstyled">
<?php foreach ($value as $view) : ?>
<li>
<?php
$overrideLinkUrl = 'index.php?option=com_templates&view=template&task=template.overrides&folder=' . $view->path
. '&id=' . $input->getInt('id') . '&file=' . $this->file . '&' . $token;
?>
<a class="component-file-url" href="<?php echo JRoute::_($overrideLinkUrl); ?>">
<i class="fa fa-files-o"></i> <?php echo $view->name; ?>
</a>
</li>
<?php endforeach; ?>
</ul>
</li>
<?php endforeach; ?>
</ul>
</div>
<div class="col-md-4">
<legend><?php echo JText::_('COM_TEMPLATES_OVERRIDES_LAYOUTS'); ?></legend>
<ul class="nav flex-column">
<?php $token = JSession::getFormToken() . '=' . 1; ?>
<?php foreach ($this->overridesList['layouts'] as $layout) : ?>
<li>
<?php
$overrideLinkUrl = 'index.php?option=com_templates&view=template&task=template.overrides&folder=' . $layout->path
. '&id=' . $input->getInt('id') . '&file=' . $this->file . '&' . $token;
?>
<a href="<?php echo JRoute::_($overrideLinkUrl); ?>">
<i class="fa fa-files-o"></i> <?php echo $layout->name; ?>
</a>
</li>
<?php endforeach; ?>
</ul>
</div>
</div>
<?php echo JHtml::_('bootstrap.endTab'); ?>
<?php echo JHtml::_('bootstrap.addTab', 'myTab', 'description', JText::_('COM_TEMPLATES_TAB_DESCRIPTION')); ?>
<?php echo $this->loadTemplate('description'); ?>
<?php echo JHtml::_('bootstrap.endTab'); ?>
<?php echo JHtml::_('bootstrap.endTabSet'); ?>
<?php // Collapse Modal
$copyModalData = array(
'selector' => 'copyModal',
'params' => array(
'title' => JText::_('COM_TEMPLATES_TEMPLATE_COPY'),
'footer' => $this->loadTemplate('modal_copy_footer')
),
'body' => $this->loadTemplate('modal_copy_body')
);
?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&task=template.copy&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<?php echo JLayoutHelper::render('joomla.modal.main', $copyModalData); ?>
<?php echo JHtml::_('form.token'); ?>
</form>
<?php if ($this->type != 'home') : ?>
<?php // Rename Modal
$renameModalData = array(
'selector' => 'renameModal',
'params' => array(
'title' => JText::sprintf('COM_TEMPLATES_RENAME_FILE', $this->fileName),
'footer' => $this->loadTemplate('modal_rename_footer')
),
'body' => $this->loadTemplate('modal_rename_body')
);
?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&task=template.renameFile&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post">
<?php echo JLayoutHelper::render('joomla.modal.main', $renameModalData); ?>
<?php echo JHtml::_('form.token'); ?>
</form>
<?php endif; ?>
<?php if ($this->type != 'home') : ?>
<?php // Delete Modal
$deleteModalData = array(
'selector' => 'deleteModal',
'params' => array(
'title' => JText::_('COM_TEMPLATES_ARE_YOU_SURE'),
'footer' => $this->loadTemplate('modal_delete_footer')
),
'body' => $this->loadTemplate('modal_delete_body')
);
?>
<?php echo JLayoutHelper::render('joomla.modal.main', $deleteModalData); ?>
<?php endif; ?>
<?php // File Modal
$fileModalData = array(
'selector' => 'fileModal',
'params' => array(
'title' => JText::_('COM_TEMPLATES_NEW_FILE_HEADER'),
'footer' => $this->loadTemplate('modal_file_footer')
),
'body' => $this->loadTemplate('modal_file_body')
);
?>
<?php echo JLayoutHelper::render('joomla.modal.main', $fileModalData); ?>
<?php // Folder Modal
$folderModalData = array(
'selector' => 'folderModal',
'params' => array(
'title' => JText::_('COM_TEMPLATES_MANAGE_FOLDERS'),
'footer' => $this->loadTemplate('modal_folder_footer')
),
'body' => $this->loadTemplate('modal_folder_body')
);
?>
<?php echo JLayoutHelper::render('joomla.modal.main', $folderModalData); ?>
<?php if ($this->type != 'home') : ?>
<?php // Resize Modal
$resizeModalData = array(
'selector' => 'resizeModal',
'params' => array(
'title' => JText::_('COM_TEMPLATES_RESIZE_IMAGE'),
'footer' => $this->loadTemplate('modal_resize_footer')
),
'body' => $this->loadTemplate('modal_resize_body')
);
?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&task=template.resizeImage&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post">
<?php echo JLayoutHelper::render('joomla.modal.main', $resizeModalData); ?>
<?php echo JHtml::_('form.token'); ?>
</form>
<?php endif; ?> | Java |
<!-- This HTML file has been created by texi2html 1.27
from emacs.texi on 3 March 1994 -->
<TITLE>GNU Emacs Manual - Commands for Human Languages</TITLE>
<P>Go to the <A HREF="emacs_24.html">previous</A>, <A HREF="emacs_26.html">next</A> section.<P>
<A NAME="IDX723"></A>
<A NAME="IDX724"></A>
<H1><A NAME="SEC155" HREF="emacs_toc.html#SEC155">Commands for Human Languages</A></H1>
<P>
The term <DFN>text</DFN> has two widespread meanings in our area of the
computer field. One is data that is a sequence of characters. Any file
that you edit with Emacs is text, in this sense of the word. The other
meaning is more restrictive: a sequence of characters in a human language
for humans to read (possibly after processing by a text formatter), as
opposed to a program or commands for a program.
<P>
Human languages have syntactic/stylistic conventions that can be
supported or used to advantage by editor commands: conventions involving
words, sentences, paragraphs, and capital letters. This chapter
describes Emacs commands for all of these things. There are also
commands for <DFN>filling</DFN>, which means rearranging the lines of a
paragraph to be approximately equal in length. The commands for moving
over and killing words, sentences and paragraphs, while intended
primarily for editing text, are also often useful for editing programs.
<P>
Emacs has several major modes for editing human language text.
If the file contains text pure and simple, use Text mode, which customizes
Emacs in small ways for the syntactic conventions of text. For text which
contains embedded commands for text formatters, Emacs has other major modes,
each for a particular text formatter. Thus, for input to TeX, you would
use TeX mode; for input to nroff, Nroff mode.
<P>
<A NAME="IDX725"></A>
<A NAME="IDX726"></A>
<H2><A NAME="SEC156" HREF="emacs_toc.html#SEC156">Words</A></H2>
<P>
Emacs has commands for moving over or operating on words. By convention,
the keys for them are all Meta characters.
<P>
<DL COMPACT>
<DT><KBD>M-f</KBD>
<DD>Move forward over a word (<CODE>forward-word</CODE>).
<DT><KBD>M-b</KBD>
<DD>Move backward over a word (<CODE>backward-word</CODE>).
<DT><KBD>M-d</KBD>
<DD>Kill up to the end of a word (<CODE>kill-word</CODE>).
<DT><KBD>M-<KBD>DEL</KBD></KBD>
<DD>Kill back to the beginning of a word (<CODE>backward-kill-word</CODE>).
<DT><KBD>M-@</KBD>
<DD>Mark the end of the next word (<CODE>mark-word</CODE>).
<DT><KBD>M-t</KBD>
<DD>Transpose two words or drag a word across other words
(<CODE>transpose-words</CODE>).
</DL>
<P>
Notice how these keys form a series that parallels the
character-based <KBD>C-f</KBD>, <KBD>C-b</KBD>, <KBD>C-d</KBD>, <KBD>C-t</KBD> and
<KBD>DEL</KBD>. <KBD>M-@</KBD> is related to <KBD>C-@</KBD>, which is an alias for
<KBD>C-<KBD>SPC</KBD></KBD>.<A NAME="IDX727"></A>
<A NAME="IDX728"></A>
<A NAME="IDX729"></A>
<A NAME="IDX730"></A>
<P>
The commands <KBD>M-f</KBD> (<CODE>forward-word</CODE>) and <KBD>M-b</KBD>
(<CODE>backward-word</CODE>) move forward and backward over words. These
Meta characters are thus analogous to the corresponding control
characters, <KBD>C-f</KBD> and <KBD>C-b</KBD>, which move over single characters
in the text. The analogy extends to numeric arguments, which serve as
repeat counts. <KBD>M-f</KBD> with a negative argument moves backward, and
<KBD>M-b</KBD> with a negative argument moves forward. Forward motion
stops right after the last letter of the word, while backward motion
stops right before the first letter.<A NAME="IDX731"></A>
<A NAME="IDX732"></A>
<P>
<KBD>M-d</KBD> (<CODE>kill-word</CODE>) kills the word after point. To be
precise, it kills everything from point to the place <KBD>M-f</KBD> would
move to. Thus, if point is in the middle of a word, <KBD>M-d</KBD> kills
just the part after point. If some punctuation comes between point and the
next word, it is killed along with the word. (If you wish to kill only the
next word but not the punctuation before it, simply do <KBD>M-f</KBD> to get
the end, and kill the word backwards with <KBD>M-<KBD>DEL</KBD></KBD>.)
<KBD>M-d</KBD> takes arguments just like <KBD>M-f</KBD>.
<A NAME="IDX733"></A>
<A NAME="IDX734"></A>
<P>
<KBD>M-<KBD>DEL</KBD></KBD> (<CODE>backward-kill-word</CODE>) kills the word before
point. It kills everything from point back to where <KBD>M-b</KBD> would
move to. If point is after the space in <SAMP>`FOO, BAR'</SAMP>, then
<SAMP>`FOO, '</SAMP> is killed. (If you wish to kill just <SAMP>`FOO'</SAMP>, do
<KBD>M-b M-d</KBD> instead of <KBD>M-<KBD>DEL</KBD></KBD>.)
<A NAME="IDX735"></A>
<A NAME="IDX736"></A>
<P>
<KBD>M-t</KBD> (<CODE>transpose-words</CODE>) exchanges the word before or
containing point with the following word. The delimiter characters between
the words do not move. For example, <SAMP>`FOO, BAR'</SAMP> transposes into
<SAMP>`BAR, FOO'</SAMP> rather than <SAMP>`BAR FOO,'</SAMP>. See section <A HREF="emacs_18.html#SEC93">Transposing Text</A>, for
more on transposition and on arguments to transposition commands.
<A NAME="IDX737"></A>
<A NAME="IDX738"></A>
<P>
To operate on the next <VAR>n</VAR> words with an operation which applies
between point and mark, you can either set the mark at point and then move
over the words, or you can use the command <KBD>M-@</KBD> (<CODE>mark-word</CODE>)
which does not move point, but sets the mark where <KBD>M-f</KBD> would move
to. <KBD>M-@</KBD> accepts a numeric argument that says how many words to
scan for the place to put the mark.
<P>
The word commands' understanding of syntax is completely controlled by
the syntax table. Any character can, for example, be declared to be a word
delimiter. See section <A HREF="emacs_35.html#SEC355">The Syntax Table</A>.
<P>
<A NAME="IDX739"></A>
<A NAME="IDX740"></A>
<H2><A NAME="SEC157" HREF="emacs_toc.html#SEC157">Sentences</A></H2>
<P>
The Emacs commands for manipulating sentences and paragraphs are mostly
on Meta keys, so as to be like the word-handling commands.
<P>
<DL COMPACT>
<DT><KBD>M-a</KBD>
<DD>Move back to the beginning of the sentence (<CODE>backward-sentence</CODE>).
<DT><KBD>M-e</KBD>
<DD>Move forward to the end of the sentence (<CODE>forward-sentence</CODE>).
<DT><KBD>M-k</KBD>
<DD>Kill forward to the end of the sentence (<CODE>kill-sentence</CODE>).
<DT><KBD>C-x <KBD>DEL</KBD></KBD>
<DD>Kill back to the beginning of the sentence (<CODE>backward-kill-sentence</CODE>).
</DL>
<A NAME="IDX741"></A>
<A NAME="IDX742"></A>
<A NAME="IDX743"></A>
<A NAME="IDX744"></A>
<P>
The commands <KBD>M-a</KBD> and <KBD>M-e</KBD> (<CODE>backward-sentence</CODE> and
<CODE>forward-sentence</CODE>) move to the beginning and end of the current
sentence, respectively. They were chosen to resemble <KBD>C-a</KBD> and
<KBD>C-e</KBD>, which move to the beginning and end of a line. Unlike them,
<KBD>M-a</KBD> and <KBD>M-e</KBD> if repeated or given numeric arguments move over
successive sentences. Emacs assumes that the typist's convention is
followed, and thus considers a sentence to end wherever there is a
<SAMP>`.'</SAMP>, <SAMP>`?'</SAMP> or <SAMP>`!'</SAMP> followed by the end of a line or two spaces,
with any number of <SAMP>`)'</SAMP>, <SAMP>`]'</SAMP>, <SAMP>`''</SAMP>, or <SAMP>`"'</SAMP> characters
allowed in between. A sentence also begins or ends wherever a paragraph
begins or ends.<P>
Neither <KBD>M-a</KBD> nor <KBD>M-e</KBD> moves past the newline or spaces beyond
the sentence edge at which it is stopping.
<A NAME="IDX745"></A>
<A NAME="IDX746"></A>
<A NAME="IDX747"></A>
<A NAME="IDX748"></A>
<P>
Just as <KBD>C-a</KBD> and <KBD>C-e</KBD> have a kill command, <KBD>C-k</KBD>, to go
with them, so <KBD>M-a</KBD> and <KBD>M-e</KBD> have a corresponding kill command
<KBD>M-k</KBD> (<CODE>kill-sentence</CODE>) which kills from point to the end of the
sentence. With minus one as an argument it kills back to the beginning of
the sentence. Larger arguments serve as a repeat count.<P>
There is a special command, <KBD>C-x <KBD>DEL</KBD></KBD>
(<CODE>backward-kill-sentence</CODE>) for killing back to the beginning of a
sentence, because this is useful when you change your mind in the middle of
composing text.<A NAME="IDX749"></A>
<P>
The variable <CODE>sentence-end</CODE> controls recognition of the end of a
sentence. It is a regexp that matches the last few characters of a
sentence, together with the whitespace following the sentence. Its
normal value is
<P>
<PRE>
"[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"
</PRE>
<P>
This example is explained in the section on regexps. See section <A HREF="emacs_17.html#SEC83">Syntax of Regular Expressions</A>.
<P>
<A NAME="IDX750"></A>
<A NAME="IDX751"></A>
<A NAME="IDX752"></A>
<A NAME="IDX753"></A>
<A NAME="IDX754"></A>
<A NAME="IDX755"></A>
<H2><A NAME="SEC158" HREF="emacs_toc.html#SEC158">Paragraphs</A></H2>
<P>
The Emacs commands for manipulating paragraphs are also Meta keys.
<P>
<DL COMPACT>
<DT><KBD>M-{</KBD>
<DD>Move back to previous paragraph beginning (<CODE>backward-paragraph</CODE>).
<DT><KBD>M-}</KBD>
<DD>Move forward to next paragraph end (<CODE>forward-paragraph</CODE>).
<DT><KBD>M-h</KBD>
<DD>Put point and mark around this or next paragraph (<CODE>mark-paragraph</CODE>).
</DL>
<P>
<KBD>M-{</KBD> moves to the beginning of the current or previous paragraph,
while <KBD>M-}</KBD> moves to the end of the current or next paragraph.
Blank lines and text formatter command lines separate paragraphs and are
not part of any paragraph. Also, an indented line starts a new
paragraph.
<P>
In major modes for programs (as opposed to Text mode), paragraphs begin
and end only at blank lines. This makes the paragraph commands continue to
be useful even though there are no paragraphs per se.
<P>
When there is a fill prefix, then paragraphs are delimited by all lines
which don't start with the fill prefix. See section <A HREF="emacs_25.html#SEC160">Filling Text</A>.
<A NAME="IDX756"></A>
<A NAME="IDX757"></A>
<P>
When you wish to operate on a paragraph, you can use the command
<KBD>M-h</KBD> (<CODE>mark-paragraph</CODE>) to set the region around it. This
command puts point at the beginning and mark at the end of the paragraph
point was in. If point is between paragraphs (in a run of blank lines, or
at a boundary), the paragraph following point is surrounded by point and
mark. If there are blank lines preceding the first line of the paragraph,
one of these blank lines is included in the region. Thus, for example,
<KBD>M-h C-w</KBD> kills the paragraph around or after point.
<A NAME="IDX758"></A>
<A NAME="IDX759"></A>
<P>
The precise definition of a paragraph boundary is controlled by the
variables <CODE>paragraph-separate</CODE> and <CODE>paragraph-start</CODE>. The
value of <CODE>paragraph-start</CODE> is a regexp that should match any line
that either starts or separates paragraphs. The value of
<CODE>paragraph-separate</CODE> is another regexp that should match only lines
that separate paragraphs without being part of any paragraph. Lines
that start a new paragraph and are contained in it must match only
<CODE>paragraph-start</CODE>, not <CODE>paragraph-separate</CODE>. For example,
normally <CODE>paragraph-start</CODE> is <CODE>"^[ <TT>\</TT>t<TT>\</TT>n<TT>\</TT>f]"</CODE> and
<CODE>paragraph-separate</CODE> is <CODE>"^[ <TT>\</TT>t<TT>\</TT>f]*$"</CODE>.<P>
Normally it is desirable for page boundaries to separate paragraphs.
The default values of these variables recognize the usual separator for
pages.
<P>
<H2><A NAME="SEC159" HREF="emacs_toc.html#SEC159">Pages</A></H2>
<A NAME="IDX760"></A>
<A NAME="IDX761"></A>
<P>
Files are often thought of as divided into <DFN>pages</DFN> by the
<DFN>formfeed</DFN> character (ASCII control-L, octal code 014). For example,
if a file is printed on a line printer, each page of the file, in this
sense, will start on a new page of paper. Emacs treats a page-separator
character just like any other character. You can insert it with <KBD>C-q
C-l</KBD>, or delete it with <KBD>DEL</KBD>. Thus, you are free to paginate your file
or not. However, since pages are often meaningful divisions of the file,
Emacs provides commands to move over them and operate on them.
<P>
<DL COMPACT>
<DT><KBD>C-x [</KBD>
<DD>Move point to previous page boundary (<CODE>backward-page</CODE>).
<DT><KBD>C-x ]</KBD>
<DD>Move point to next page boundary (<CODE>forward-page</CODE>).
<DT><KBD>C-x C-p</KBD>
<DD>Put point and mark around this page (or another page) (<CODE>mark-page</CODE>).
<DT><KBD>C-x l</KBD>
<DD>Count the lines in this page (<CODE>count-lines-page</CODE>).
</DL>
<A NAME="IDX762"></A>
<A NAME="IDX763"></A>
<A NAME="IDX764"></A>
<A NAME="IDX765"></A>
<P>
The <KBD>C-x [</KBD> (<CODE>backward-page</CODE>) command moves point to immediately
after the previous page delimiter. If point is already right after a page
delimiter, it skips that one and stops at the previous one. A numeric
argument serves as a repeat count. The <KBD>C-x ]</KBD> (<CODE>forward-page</CODE>)
command moves forward past the next page delimiter.
<A NAME="IDX766"></A>
<A NAME="IDX767"></A>
<P>
The <KBD>C-x C-p</KBD> command (<CODE>mark-page</CODE>) puts point at the beginning
of the current page and the mark at the end. The page delimiter at the end
is included (the mark follows it). The page delimiter at the front is
excluded (point follows it). This command can be followed by <KBD>C-w</KBD> to
kill a page which is to be moved elsewhere. If it is inserted after a page
delimiter, at a place where <KBD>C-x ]</KBD> or <KBD>C-x [</KBD> would take you, then
the page will be properly delimited before and after once again.
<P>
A numeric argument to <KBD>C-x C-p</KBD> is used to specify which page to go
to, relative to the current one. Zero means the current page. One means
the next page, and -1 means the previous one.
<A NAME="IDX768"></A>
<A NAME="IDX769"></A>
<P>
The <KBD>C-x l</KBD> command (<CODE>count-lines-page</CODE>) is good for deciding
where to break a page in two. It prints in the echo area the total number
of lines in the current page, and then divides it up into those preceding
the current line and those following, as in
<P>
<PRE>
Page has 96 (72+25) lines
</PRE>
<P>
Notice that the sum is off by one; this is correct if point is not at the
beginning of a line.
<A NAME="IDX770"></A>
<P>
The variable <CODE>page-delimiter</CODE> controls where pages begin. Its
value is a regexp that matches the beginning of a line that separates
pages. The normal value of this variable is <CODE>"^<TT>\</TT>f"</CODE>, which
matches a formfeed character at the beginning of a line.
<P>
<A NAME="IDX771"></A>
<H2><A NAME="SEC160" HREF="emacs_toc.html#SEC160">Filling Text</A></H2>
<P>
With Auto Fill mode, text can be <DFN>filled</DFN> (broken up into lines
that fit in a specified width) as you insert it. If you alter existing
text it may no longer be properly filled; then you can use the explicit
fill commands to fill the paragraph again.
<P>
<A NAME="IDX772"></A>
<A NAME="IDX773"></A>
<H3><A NAME="SEC161" HREF="emacs_toc.html#SEC161">Auto Fill Mode</A></H3>
<P>
<DFN>Auto Fill</DFN> mode is a minor mode in which lines are broken
automatically when they become too wide. Breaking happens only when
you type a <KBD>SPC</KBD> or <KBD>RET</KBD>.
<P>
<DL COMPACT>
<DT><KBD>M-x auto-fill-mode</KBD>
<DD>Enable or disable Auto Fill mode.
<DT><KBD><KBD>SPC</KBD></KBD>
<DD><DT><KBD><KBD>RET</KBD></KBD>
<DD>In Auto Fill mode, break lines when appropriate.
</DL>
<A NAME="IDX774"></A>
<P>
<KBD>M-x auto-fill-mode</KBD> turns Auto Fill mode on if it was off, or off if
it was on. With a positive numeric argument it always turns Auto Fill mode
on, and with a negative argument always turns it off. You can see when
Auto Fill mode is in effect by the presence of the word <SAMP>`Fill'</SAMP> in the
mode line, inside the parentheses. Auto Fill mode is a minor mode, turned
on or off for each buffer individually. See section <A HREF="emacs_35.html#SEC333">Minor Modes</A>.
<P>
In Auto Fill mode, lines are broken automatically at spaces when they get
longer than the desired width. Line breaking and rearrangement takes place
only when you type <KBD>SPC</KBD> or <KBD>RET</KBD>. If you wish to insert a space
or newline without permitting line-breaking, type <KBD>C-q <KBD>SPC</KBD></KBD> or
<KBD>C-q <KBD>LFD</KBD></KBD> (recall that a newline is really a linefeed). Also,
<KBD>C-o</KBD> inserts a newline without line breaking.
<P>
Auto Fill mode works well with Lisp mode, because when it makes a new
line in Lisp mode it indents that line with <KBD>TAB</KBD>. If a line ending in
a comment gets too long, the text of the comment is split into two
comment lines. Optionally new comment delimiters are inserted at the end of
the first line and the beginning of the second so that each line is
a separate comment; the variable <CODE>comment-multi-line</CODE> controls the
choice (see section <A HREF="emacs_26.html#SEC187">Manipulating Comments</A>).
<P>
Auto Fill mode does not refill entire paragraphs. It can break lines but
cannot merge lines. So editing in the middle of a paragraph can result in
a paragraph that is not correctly filled. The easiest way to make the
paragraph properly filled again is usually with the explicit fill commands.
<P>
Many users like Auto Fill mode and want to use it in all text files.
The section on init files says how to arrange this permanently for yourself.
See section <A HREF="emacs_35.html#SEC356">The Init File, <TT>`~/.emacs'</TT></A>.
<P>
<H3><A NAME="SEC162" HREF="emacs_toc.html#SEC162">Explicit Fill Commands</A></H3>
<P>
<DL COMPACT>
<DT><KBD>M-q</KBD>
<DD>Fill current paragraph (<CODE>fill-paragraph</CODE>).
<DT><KBD>C-x f</KBD>
<DD>Set the fill column (<CODE>set-fill-column</CODE>).
<DT><KBD>M-x fill-region</KBD>
<DD>Fill each paragraph in the region (<CODE>fill-region</CODE>).
<DT><KBD>M-x fill-region-as-paragraph.</KBD>
<DD>Fill the region, considering it as one paragraph.
<DT><KBD>M-s</KBD>
<DD>Center a line.
</DL>
<A NAME="IDX775"></A>
<A NAME="IDX776"></A>
<P>
To refill a paragraph, use the command <KBD>M-q</KBD>
(<CODE>fill-paragraph</CODE>). This operates on the paragraph that point is
inside, or the one after point if point is between paragraphs.
Refilling works by removing all the line-breaks, then inserting new ones
where necessary.
<A NAME="IDX777"></A>
<A NAME="IDX778"></A>
<A NAME="IDX779"></A>
<P>
The command <KBD>M-s</KBD> (<CODE>center-line</CODE>) centers the current line
within the current fill column. With an argument, it centers several lines
individually and moves past them.
<A NAME="IDX780"></A>
<P>
To refill many paragraphs, use <KBD>M-x fill-region</KBD>, which
divides the region into paragraphs and fills each of them.
<A NAME="IDX781"></A>
<P>
<KBD>M-q</KBD> and <CODE>fill-region</CODE> use the same criteria as <KBD>M-h</KBD>
for finding paragraph boundaries (see section <A HREF="emacs_25.html#SEC158">Paragraphs</A>). For more
control, you can use <KBD>M-x fill-region-as-paragraph</KBD>, which refills
everything between point and mark. This command deletes any blank lines
within the region, so separate blocks of text end up combined into one
block.<A NAME="IDX782"></A>
<P>
A numeric argument to <KBD>M-q</KBD> causes it to <DFN>justify</DFN> the text as
well as filling it. This means that extra spaces are inserted to make
the right margin line up exactly at the fill column. To remove the
extra spaces, use <KBD>M-q</KBD> with no argument. (Likewise for
<CODE>fill-region</CODE>.)
<A NAME="IDX783"></A>
<A NAME="IDX784"></A>
<P>
When <CODE>adaptive-fill-mode</CODE> is non-<CODE>nil</CODE> (which is normally
the case), if you use <CODE>fill-region-as-paragraph</CODE> on an indented
paragraph and you don't have a fill prefix, it uses the indentation of
the second line of the paragraph as the fill prefix. The effect of
adaptive filling is not noticeable in Text mode, because an indented
line counts as a paragraph starter and thus each line of an indented
paragraph is considered a paragraph of its own. But you do notice the
effect in Indented Text mode and some other major modes.
<A NAME="IDX785"></A>
<P>
The maximum line width for filling is in the variable <CODE>fill-column</CODE>.
Altering the value of <CODE>fill-column</CODE> makes it local to the current
buffer; until that time, the default value is in effect. The default is
initially 70. See section <A HREF="emacs_35.html#SEC338">Local Variables</A>.
<A NAME="IDX786"></A>
<A NAME="IDX787"></A>
<P>
The easiest way to set <CODE>fill-column</CODE> is to use the command <KBD>C-x
f</KBD> (<CODE>set-fill-column</CODE>). With no argument, it sets <CODE>fill-column</CODE>
to the current horizontal position of point. With a numeric argument, it
uses that as the new fill column.
<P>
<H3><A NAME="SEC163" HREF="emacs_toc.html#SEC163">The Fill Prefix</A></H3>
<A NAME="IDX788"></A>
<P>
To fill a paragraph in which each line starts with a special marker
(which might be a few spaces, giving an indented paragraph), use the
<DFN>fill prefix</DFN> feature. The fill prefix is a string which Emacs expects
every line to start with, and which is not included in filling.
<P>
<DL COMPACT>
<DT><KBD>C-x .</KBD>
<DD>Set the fill prefix (<CODE>set-fill-prefix</CODE>).
<DT><KBD>M-q</KBD>
<DD>Fill a paragraph using current fill prefix (<CODE>fill-paragraph</CODE>).
<DT><KBD>M-x fill-individual-paragraphs</KBD>
<DD>Fill the region, considering each change of indentation as starting a
new paragraph.
<DT><KBD>M-x fill-nonuniform-paragraphs</KBD>
<DD>Fill the region, considering only paragraph-separator lines as starting
a new paragraph.
</DL>
<A NAME="IDX789"></A>
<A NAME="IDX790"></A>
<P>
To specify a fill prefix, move to a line that starts with the desired
prefix, put point at the end of the prefix, and give the command
<KBD>C-x .</KBD> (<CODE>set-fill-prefix</CODE>). That's a period after the
<KBD>C-x</KBD>. To turn off the fill prefix, specify an empty prefix: type
<KBD>C-x .</KBD> with point at the beginning of a line.<P>
When a fill prefix is in effect, the fill commands remove the fill prefix
from each line before filling and insert it on each line after filling.
The fill prefix is also inserted on new lines made automatically by Auto
Fill mode. Lines that do not start with the fill prefix are considered to
start paragraphs, both in <KBD>M-q</KBD> and the paragraph commands; this is
just right if you are using paragraphs with hanging indentation (every line
indented except the first one). Lines which are blank or indented once the
prefix is removed also separate or start paragraphs; this is what you want
if you are writing multi-paragraph comments with a comment delimiter on
each line.
<P>
For example, if <CODE>fill-column</CODE> is 40 and you set the fill prefix
to <SAMP>`;; '</SAMP>, then <KBD>M-q</KBD> in the following text
<P>
<PRE>
;; This is an
;; example of a paragraph
;; inside a Lisp-style comment.
</PRE>
<P>
produces this:
<P>
<PRE>
;; This is an example of a paragraph
;; inside a Lisp-style comment.
</PRE>
<P>
The <KBD>C-o</KBD> command inserts the fill prefix on new lines it creates,
when you use it at the beginning of a line (see section <A HREF="emacs_8.html#SEC25">Blank Lines</A>).
Conversely, the command <KBD>M-^</KBD> deletes the prefix (if it occurs)
after the newline that it deletes (see section <A HREF="emacs_24.html#SEC151">Indentation</A>).
<A NAME="IDX791"></A>
<P>
You can use <KBD>M-x fill-individual-paragraphs</KBD> to set the fill
prefix for each paragraph automatically. This command divides the
region into paragraphs, treating every change in the amount of
indentation as the start of a new paragraph, and fills each of these
paragraphs. Thus, all the lines in one "paragraph" have the same
amount of indentation. That indentation serves as the fill prefix for
that paragraph.
<A NAME="IDX792"></A>
<P>
<KBD>M-x fill-nonuniform-paragraphs</KBD> is a similar command that divides
the region into paragraphs in a different way. It considers only
paragraph-separating lines (as defined by <CODE>paragraph-separate</CODE>) as
starting a new paragraph. Since this means that the lines of one
paragraph may have different amounts of indentation, the fill prefix
used is the smallest amount of indentation of any of the lines of the
paragraph.
<A NAME="IDX793"></A>
<P>
The fill prefix is stored in the variable <CODE>fill-prefix</CODE>. Its value
is a string, or <CODE>nil</CODE> when there is no fill prefix. This is a
per-buffer variable; altering the variable affects only the current buffer,
but there is a default value which you can change as well. See section <A HREF="emacs_35.html#SEC338">Local Variables</A>.
<P>
<A NAME="IDX794"></A>
<H2><A NAME="SEC164" HREF="emacs_toc.html#SEC164">Case Conversion Commands</A></H2>
<P>
Emacs has commands for converting either a single word or any arbitrary
range of text to upper case or to lower case.
<P>
<DL COMPACT>
<DT><KBD>M-l</KBD>
<DD>Convert following word to lower case (<CODE>downcase-word</CODE>).
<DT><KBD>M-u</KBD>
<DD>Convert following word to upper case (<CODE>upcase-word</CODE>).
<DT><KBD>M-c</KBD>
<DD>Capitalize the following word (<CODE>capitalize-word</CODE>).
<DT><KBD>C-x C-l</KBD>
<DD>Convert region to lower case (<CODE>downcase-region</CODE>).
<DT><KBD>C-x C-u</KBD>
<DD>Convert region to upper case (<CODE>upcase-region</CODE>).
</DL>
<A NAME="IDX795"></A>
<A NAME="IDX796"></A>
<A NAME="IDX797"></A>
<A NAME="IDX798"></A>
<A NAME="IDX799"></A>
<A NAME="IDX800"></A>
<A NAME="IDX801"></A>
<A NAME="IDX802"></A>
<A NAME="IDX803"></A>
<P>
The word conversion commands are the most useful. <KBD>M-l</KBD>
(<CODE>downcase-word</CODE>) converts the word after point to lower case, moving
past it. Thus, repeating <KBD>M-l</KBD> converts successive words.
<KBD>M-u</KBD> (<CODE>upcase-word</CODE>) converts to all capitals instead, while
<KBD>M-c</KBD> (<CODE>capitalize-word</CODE>) puts the first letter of the word
into upper case and the rest into lower case. All these commands convert
several words at once if given an argument. They are especially convenient
for converting a large amount of text from all upper case to mixed case,
because you can move through the text using <KBD>M-l</KBD>, <KBD>M-u</KBD> or
<KBD>M-c</KBD> on each word as appropriate, occasionally using <KBD>M-f</KBD> instead
to skip a word.
<P>
When given a negative argument, the word case conversion commands apply
to the appropriate number of words before point, but do not move point.
This is convenient when you have just typed a word in the wrong case: you
can give the case conversion command and continue typing.
<P>
If a word case conversion command is given in the middle of a word, it
applies only to the part of the word which follows point. This is just
like what <KBD>M-d</KBD> (<CODE>kill-word</CODE>) does. With a negative argument,
case conversion applies only to the part of the word before point.
<A NAME="IDX804"></A>
<A NAME="IDX805"></A>
<A NAME="IDX806"></A>
<A NAME="IDX807"></A>
<P>
The other case conversion commands are <KBD>C-x C-u</KBD>
(<CODE>upcase-region</CODE>) and <KBD>C-x C-l</KBD> (<CODE>downcase-region</CODE>), which
convert everything between point and mark to the specified case. Point and
mark do not move.
<P>
The region case conversion commands <CODE>upcase-region</CODE> and
<CODE>downcase-region</CODE> are normally disabled. This means that they ask
for confirmation if you try to use them. When you confirm, you may
enable the command, which means it will not ask for confirmation again.
See section <A HREF="emacs_35.html#SEC353">Disabling Commands</A>.
<P>
<A NAME="IDX808"></A>
<A NAME="IDX809"></A>
<A NAME="IDX810"></A>
<H2><A NAME="SEC165" HREF="emacs_toc.html#SEC165">Text Mode</A></H2>
<P>
When you edit files of text in a human language, it's more convenient
to use Text mode rather than Fundamental mode. Invoke <KBD>M-x
text-mode</KBD> to enter Text mode. In Text mode, <KBD>TAB</KBD> runs the
function <CODE>tab-to-tab-stop</CODE>, which allows you to use arbitrary tab
stops set with <KBD>M-x edit-tab-stops</KBD> (see section <A HREF="emacs_24.html#SEC153">Tab Stops</A>). Features
concerned with comments in programs are turned off except when
explicitly invoked. The syntax table is changed so that periods are not
considered part of a word, while apostrophes, backspaces and underlines
are.
<A NAME="IDX811"></A>
<A NAME="IDX812"></A>
<A NAME="IDX813"></A>
<A NAME="IDX814"></A>
<P>
A similar variant mode is Indented Text mode, intended for editing
text in which most lines are indented. This mode defines <KBD>TAB</KBD> to
run <CODE>indent-relative</CODE> (see section <A HREF="emacs_24.html#SEC151">Indentation</A>), and makes Auto Fill
indent the lines it creates. The result is that normally a line made by
Auto Filling, or by <KBD>LFD</KBD>, is indented just like the previous line.
In Indented Text mode, only blank lines separate paragraphs--indented
lines continue the current paragraph. Use <KBD>M-x indented-text-mode</KBD>
to select this mode.
<A NAME="IDX815"></A>
<P>
Text mode, and all the modes based on it, define <KBD>M-<KBD>TAB</KBD></KBD> as
the command <CODE>ispell-complete-word</CODE>, which performs completion of
the partial word in the buffer before point, using the spelling
dictionary as the space of possible words. See section <A HREF="emacs_18.html#SEC95">Checking and Correcting Spelling</A>.
<A NAME="IDX816"></A>
<P>
Entering Text mode or Indented Text mode runs the hook
<CODE>text-mode-hook</CODE>. Other major modes related to Text mode also run
this hook, followed by hooks of their own; this includes Nroff mode,
TeX mode, Outline mode and Mail mode. Hook functions on
<CODE>text-mode-hook</CODE> can look at the value of <CODE>major-mode</CODE> to see
which of these modes is actually being entered. See section <A HREF="emacs_35.html#SEC337">Hooks</A>.
<P>
<A NAME="IDX817"></A>
<A NAME="IDX818"></A>
<A NAME="IDX819"></A>
<A NAME="IDX820"></A>
<H2><A NAME="SEC166" HREF="emacs_toc.html#SEC166">Outline Mode</A></H2>
<A NAME="IDX821"></A>
<A NAME="IDX822"></A>
<P>
Outline mode is a major mode much like Text mode but intended for
editing outlines. It allows you to make parts of the text temporarily
invisible so that you can see just the overall structure of the
outline. Type <KBD>M-x outline-mode</KBD> to switch to Outline mode as the
major mode of the current buffer. Type <KBD>M-x outline-minor-mode</KBD>
to enable Outline mode as a minor mode in the current buffer.
When Outline minor mode is enabled, the <KBD>C-c</KBD> commands of Outline
mode replace those of the major mode.
<P>
When a line is invisible in outline mode, it does not appear on the
screen. The screen appears exactly as if the invisible line
were deleted, except that an ellipsis (three periods in a row) appears
at the end of the previous visible line (only one ellipsis no matter
how many invisible lines follow).
<P>
All editing commands treat the text of the invisible line as part of the
previous visible line. For example, <KBD>C-n</KBD> moves onto the next visible
line. Killing an entire visible line, including its terminating newline,
really kills all the following invisible lines along with it; yanking it
all back yanks the invisible lines and they remain invisible.
<A NAME="IDX823"></A>
<P>
Entering Outline mode runs the hook <CODE>text-mode-hook</CODE> followed by
the hook <CODE>outline-mode-hook</CODE> (see section <A HREF="emacs_35.html#SEC337">Hooks</A>).
<P>
<H3><A NAME="SEC167" HREF="emacs_toc.html#SEC167">Format of Outlines</A></H3>
<A NAME="IDX824"></A>
<A NAME="IDX825"></A>
<P>
Outline mode assumes that the lines in the buffer are of two types:
<DFN>heading lines</DFN> and <DFN>body lines</DFN>. A heading line represents a topic in the
outline. Heading lines start with one or more stars; the number of stars
determines the depth of the heading in the outline structure. Thus, a
heading line with one star is a major topic; all the heading lines with
two stars between it and the next one-star heading are its subtopics; and
so on. Any line that is not a heading line is a body line. Body lines
belong with the preceding heading line. Here is an example:
<P>
<PRE>
* Food
This is the body,
which says something about the topic of food.
** Delicious Food
This is the body of the second-level header.
** Distasteful Food
This could have
a body too, with
several lines.
*** Dormitory Food
* Shelter
A second first-level topic with its header line.
</PRE>
<P>
A heading line together with all following body lines is called
collectively an <DFN>entry</DFN>. A heading line together with all following
deeper heading lines and their body lines is called a <DFN>subtree</DFN>.
<A NAME="IDX826"></A>
<P>
You can customize the criterion for distinguishing heading lines
by setting the variable <CODE>outline-regexp</CODE>. Any line whose
beginning has a match for this regexp is considered a heading line.
Matches that start within a line (not at the beginning) do not count.
The length of the matching text determines the level of the heading;
longer matches make a more deeply nested level. Thus, for example,
if a text formatter has commands <SAMP>`@chapter'</SAMP>, <SAMP>`@section'</SAMP>
and <SAMP>`@subsection'</SAMP> to divide the document into chapters and
sections, you could make those lines count as heading lines by
setting <CODE>outline-regexp</CODE> to <SAMP>`"@chap\\|@\\(sub\\)*section"'</SAMP>.
Note the trick: the two words <SAMP>`chapter'</SAMP> and <SAMP>`section'</SAMP> are equally
long, but by defining the regexp to match only <SAMP>`chap'</SAMP> we ensure
that the length of the text matched on a chapter heading is shorter,
so that Outline mode will know that sections are contained in chapters.
This works as long as no other command starts with <SAMP>`@chap'</SAMP>.
<P>
Outline mode makes a line invisible by changing the newline before it
into an ASCII control-M (code 015). Most editing commands that work on
lines treat an invisible line as part of the previous line because,
strictly speaking, it <EM>is</EM> part of that line, since there is no longer a
newline in between. When you save the file in Outline mode, control-M
characters are saved as newlines, so the invisible lines become ordinary
lines in the file. But saving does not change the visibility status of a
line inside Emacs.
<P>
<H3><A NAME="SEC168" HREF="emacs_toc.html#SEC168">Outline Motion Commands</A></H3>
<P>
There are some special motion commands in Outline mode that move
backward and forward to heading lines.
<P>
<DL COMPACT>
<DT><KBD>C-c C-n</KBD>
<DD>Move point to the next visible heading line
(<CODE>outline-next-visible-heading</CODE>).
<DT><KBD>C-c C-p</KBD>
<DD>Move point to the previous visible heading line <BR>
(<CODE>outline-previous-visible-heading</CODE>).
<DT><KBD>C-c C-f</KBD>
<DD>Move point to the next visible heading line at the same level
as the one point is on (<CODE>outline-forward-same-level</CODE>).
<DT><KBD>C-c C-b</KBD>
<DD>Move point to the previous visible heading line at the same level
(<CODE>outline-backward-same-level</CODE>).
<DT><KBD>C-c C-u</KBD>
<DD>Move point up to a lower-level (more inclusive) visible heading line
(<CODE>outline-up-heading</CODE>).
</DL>
<A NAME="IDX827"></A>
<A NAME="IDX828"></A>
<A NAME="IDX829"></A>
<A NAME="IDX830"></A>
<P>
<KBD>C-c C-n</KBD> (<CODE>next-visible-heading</CODE>) moves down to the next
heading line. <KBD>C-c C-p</KBD> (<CODE>previous-visible-heading</CODE>) moves
similarly backward. Both accept numeric arguments as repeat counts. The
names emphasize that invisible headings are skipped, but this is not really
a special feature. All editing commands that look for lines ignore the
invisible lines automatically.<A NAME="IDX831"></A>
<A NAME="IDX832"></A>
<A NAME="IDX833"></A>
<A NAME="IDX834"></A>
<A NAME="IDX835"></A>
<A NAME="IDX836"></A>
<P>
More powerful motion commands understand the level structure of headings.
<KBD>C-c C-f</KBD> (<CODE>outline-forward-same-level</CODE>) and
<KBD>C-c C-b</KBD> (<CODE>outline-backward-same-level</CODE>) move from one
heading line to another visible heading at the same depth in
the outline. <KBD>C-c C-u</KBD> (<CODE>outline-up-heading</CODE>) moves
backward to another heading that is less deeply nested.
<P>
<H3><A NAME="SEC169" HREF="emacs_toc.html#SEC169">Outline Visibility Commands</A></H3>
<P>
The other special commands of outline mode are used to make lines visible
or invisible. Their names all start with <CODE>hide</CODE> or <CODE>show</CODE>.
Most of them fall into pairs of opposites. They are not undoable; instead,
you can undo right past them. Making lines visible or invisible is simply
not recorded by the undo mechanism.
<P>
<DL COMPACT>
<DT><KBD>M-x hide-body</KBD>
<DD>Make all body lines in the buffer invisible.
<DT><KBD>M-x show-all</KBD>
<DD>Make all lines in the buffer visible.
<DT><KBD>C-c C-h</KBD>
<DD>Make everything under this heading invisible, not including this
heading itself<BR> (<CODE>hide-subtree</CODE>).
<DT><KBD>C-c C-s</KBD>
<DD>Make everything under this heading visible, including body,
subheadings, and their bodies (<CODE>show-subtree</CODE>).
<DT><KBD>M-x hide-leaves</KBD>
<DD>Make the body of this heading line, and of all its subheadings,
invisible.
<DT><KBD>M-x show-branches</KBD>
<DD>Make all subheadings of this heading line, at all levels, visible.
<DT><KBD>C-c C-i</KBD>
<DD>Make immediate subheadings (one level down) of this heading line
visible (<CODE>show-children</CODE>).
<DT><KBD>M-x hide-entry</KBD>
<DD>Make this heading line's body invisible.
<DT><KBD>M-x show-entry</KBD>
<DD>Make this heading line's body visible.
</DL>
<A NAME="IDX837"></A>
<A NAME="IDX838"></A>
<P>
Two commands that are exact opposites are <KBD>M-x hide-entry</KBD> and
<KBD>M-x show-entry</KBD>. They are used with point on a heading line, and
apply only to the body lines of that heading. The subtopics and their
bodies are not affected.
<A NAME="IDX839"></A>
<A NAME="IDX840"></A>
<A NAME="IDX841"></A>
<A NAME="IDX842"></A>
<A NAME="IDX843"></A>
<P>
Two more powerful opposites are <KBD>C-c C-h</KBD> (<CODE>hide-subtree</CODE>) and
<KBD>C-c C-s</KBD> (<CODE>show-subtree</CODE>). Both expect to be used when point is
on a heading line, and both apply to all the lines of that heading's
<DFN>subtree</DFN>: its body, all its subheadings, both direct and indirect, and
all of their bodies. In other words, the subtree contains everything
following this heading line, up to and not including the next heading of
the same or higher rank.<A NAME="IDX844"></A>
<A NAME="IDX845"></A>
<P>
Intermediate between a visible subtree and an invisible one is having
all the subheadings visible but none of the body. There are two commands
for doing this, depending on whether you want to hide the bodies or
make the subheadings visible. They are <KBD>M-x hide-leaves</KBD> and
<KBD>M-x show-branches</KBD>.
<A NAME="IDX846"></A>
<A NAME="IDX847"></A>
<P>
A little weaker than <CODE>show-branches</CODE> is <KBD>C-c C-i</KBD>
(<CODE>show-children</CODE>). It makes just the direct subheadings
visible--those one level down. Deeper subheadings remain invisible, if
they were invisible.<A NAME="IDX848"></A>
<A NAME="IDX849"></A>
<P>
Two commands have a blanket effect on the whole file. <KBD>M-x hide-body</KBD>
makes all body lines invisible, so that you see just the outline structure.
<KBD>M-x show-all</KBD> makes all lines visible. These commands can be thought
of as a pair of opposites even though <KBD>M-x show-all</KBD> applies to more
than just body lines.
<P>
You can turn off the use of ellipses at the ends of visible lines by
setting <CODE>selective-display-ellipses</CODE> to <CODE>nil</CODE>. Then there is
no visible indication of the presence of invisible lines.
<P>
<A NAME="IDX850"></A>
<A NAME="IDX851"></A>
<A NAME="IDX852"></A>
<A NAME="IDX853"></A>
<A NAME="IDX854"></A>
<A NAME="IDX855"></A>
<A NAME="IDX856"></A>
<H2><A NAME="SEC170" HREF="emacs_toc.html#SEC170">TeX Mode</A></H2>
<P>
TeX is a powerful text formatter written by Donald Knuth; it is also
free, like GNU Emacs. LaTeX is a simplified input format for TeX,
implemented by TeX macros; it comes with TeX. SliTeX is a special
form of LaTeX.<P>
Emacs has a special TeX mode for editing TeX input files.
It provides facilities for checking the balance of delimiters and for
invoking TeX on all or part of the file.
<A NAME="IDX857"></A>
<P>
TeX mode has three variants, Plain TeX mode, LaTeX mode, and
SliTeX mode (these three distinct major modes differ only slightly).
They are designed for editing the three different formats. The command
<KBD>M-x tex-mode</KBD> looks at the contents of the buffer to determine
whether the contents appear to be either LaTeX input or SliTeX
input; it then selects the appropriate mode. If it can't tell which is
right (e.g., the buffer is empty), the variable <CODE>tex-default-mode</CODE>
controls which mode is used.
<P>
When <KBD>M-x tex-mode</KBD> does not guess right, you can use the commands
<KBD>M-x plain-tex-mode</KBD>, <KBD>M-x latex-mode</KBD>, and <KBD>M-x
slitex-mode</KBD> to select explicitly the particular variants of TeX
mode.
<P>
<H3><A NAME="SEC171" HREF="emacs_toc.html#SEC171">TeX Editing Commands</A></H3>
<P>
Here are the special commands provided in TeX mode for editing the
text of the file.
<P>
<DL COMPACT>
<DT><KBD>"</KBD>
<DD>Insert, according to context, either <SAMP>`"'</SAMP> or <SAMP>`"'</SAMP> or
<SAMP>`"'</SAMP> (<CODE>tex-insert-quote</CODE>).
<DT><KBD><KBD>LFD</KBD></KBD>
<DD>Insert a paragraph break (two newlines) and check the previous
paragraph for unbalanced braces or dollar signs
(<CODE>tex-terminate-paragraph</CODE>).
<DT><KBD>M-x validate-tex-region</KBD>
<DD>Check each paragraph in the region for unbalanced braces or dollar signs.
<DT><KBD>C-c {</KBD>
<DD>Insert <SAMP>`{}'</SAMP> and position point between them (<CODE>tex-insert-braces</CODE>).
<DT><KBD>C-c }</KBD>
<DD>Move forward past the next unmatched close brace (<CODE>up-list</CODE>).
</DL>
<A NAME="IDX858"></A>
<A NAME="IDX859"></A>
<P>
In TeX, the character <SAMP>`"'</SAMP> is not normally used; we use
<SAMP>`"'</SAMP> to start a quotation and <SAMP>`"'</SAMP> to end one. To make
editing easier under this formatting convention, TeX mode overrides
the normal meaning of the key <KBD>"</KBD> with a command that inserts a pair
of single-quotes or backquotes (<CODE>tex-insert-quote</CODE>). To be
precise, this command inserts <SAMP>`"'</SAMP> after whitespace or an open
brace, <SAMP>`"'</SAMP> after a backslash, and <SAMP>`"'</SAMP> after any other
character.
<P>
If you need the character <SAMP>`"'</SAMP> itself in unusual contexts, use
<KBD>C-q</KBD> to insert it. Also, <KBD>"</KBD> with a numeric argument always
inserts that number of <SAMP>`"'</SAMP> characters.
<P>
In TeX mode, <SAMP>`$'</SAMP> has a special syntax code which attempts to
understand the way TeX math mode delimiters match. When you insert a
<SAMP>`$'</SAMP> that is meant to exit math mode, the position of the matching
<SAMP>`$'</SAMP> that entered math mode is displayed for a second. This is the
same feature that displays the open brace that matches a close brace that
is inserted. However, there is no way to tell whether a <SAMP>`$'</SAMP> enters
math mode or leaves it; so when you insert a <SAMP>`$'</SAMP> that enters math
mode, the previous <SAMP>`$'</SAMP> position is shown as if it were a match, even
though they are actually unrelated.
<A NAME="IDX860"></A>
<A NAME="IDX861"></A>
<A NAME="IDX862"></A>
<A NAME="IDX863"></A>
<P>
TeX uses braces as delimiters that must match. Some users prefer
to keep braces balanced at all times, rather than inserting them
singly. Use <KBD>C-c {</KBD> (<CODE>tex-insert-braces</CODE>) to insert a pair of
braces. It leaves point between the two braces so you can insert the
text that belongs inside. Afterward, use the command <KBD>C-c }</KBD>
(<CODE>up-list</CODE>) to move forward past the close brace.
<A NAME="IDX864"></A>
<A NAME="IDX865"></A>
<A NAME="IDX866"></A>
<P>
There are two commands for checking the matching of braces. <KBD>LFD</KBD>
(<CODE>tex-terminate-paragraph</CODE>) checks the paragraph before point, and
inserts two newlines to start a new paragraph. It prints a message in the
echo area if any mismatch is found. <KBD>M-x validate-tex-region</KBD> checks
a region, paragraph by paragraph. When it finds a paragraph that
contains a mismatch, it displays point at the beginning of the paragraph
for a few seconds and pushes a mark at that spot. Scanning continues
until the whole buffer has been checked or until you type another key.
The positions of the last several paragraphs with mismatches can be
found in the mark ring (see section <A HREF="emacs_13.html#SEC52">The Mark Ring</A>).
<P>
Note that Emacs commands count square brackets and parentheses in
TeX mode, not just braces. This is not strictly correct for the
purpose of checking TeX syntax. However, parentheses and square
brackets are likely to be used in text as matching delimiters and it is
useful for the various motion commands and automatic match display to
work with them.
<P>
<H3><A NAME="SEC172" HREF="emacs_toc.html#SEC172">LaTeX Editing Commands</A></H3>
<P>
LaTeX mode provides a few extra features not applicable to plain
TeX.
<P>
<DL COMPACT>
<DT><KBD>C-c C-o</KBD>
<DD>Insert <SAMP>`\begin'</SAMP> and <SAMP>`\end'</SAMP> for LaTeX block and position
point on a line between them. (<CODE>tex-latex-block</CODE>).
<DT><KBD>C-c C-e</KBD>
<DD>Close the last unended block for LaTeX (<CODE>tex-close-latex-block</CODE>).
</DL>
<A NAME="IDX867"></A>
<A NAME="IDX868"></A>
<P>
In LaTeX input, <SAMP>`\begin'</SAMP> and <SAMP>`\end'</SAMP> commands are used to
group blocks of text. To insert a <SAMP>`\begin'</SAMP> and a matching
<SAMP>`\end'</SAMP> (on a new line following the <SAMP>`\begin'</SAMP>), use <KBD>C-c
C-o</KBD> (<CODE>tex-latex-block</CODE>). A blank line is inserted between the
two, and point is left there.<A NAME="IDX869"></A>
<P>
Emacs knows all of the standard LaTeX block names and will
permissively complete a partially entered block name
(see section <A HREF="emacs_10.html#SEC33">Completion</A>). You can add your own list of block names to those
known by Emacs with the variable <CODE>latex-block-names</CODE>. For example,
to add <SAMP>`theorem'</SAMP>, <SAMP>`corollary'</SAMP>, and <SAMP>`proof'</SAMP>, include the line
<P>
<PRE>
(setq latex-block-names '("theorem" "corollary" "proof"))
</PRE>
<P>
to your <TT>`.emacs'</TT> file.
<A NAME="IDX870"></A>
<A NAME="IDX871"></A>
<P>
In LaTeX input, <SAMP>`\begin'</SAMP> and <SAMP>`\end'</SAMP> commands must balance.
You can use <KBD>C-c C-e</KBD> (<CODE>tex-close-latex-block</CODE>) to insert
automatically a matching <SAMP>`\end'</SAMP> to match the last unmatched <SAMP>`\begin'</SAMP>.
The <SAMP>`\end'</SAMP> will be indented to match the corresponding <SAMP>`\begin'</SAMP>.
The <SAMP>`\end'</SAMP> will be followed by a newline if point is at the beginning
of a line.<P>
<H3><A NAME="SEC173" HREF="emacs_toc.html#SEC173">TeX Printing Commands</A></H3>
<P>
You can invoke TeX as an inferior of Emacs on either the entire
contents of the buffer or just a region at a time. Running TeX in
this way on just one chapter is a good way to see what your changes
look like without taking the time to format the entire file.
<P>
<DL COMPACT>
<DT><KBD>C-c C-r</KBD>
<DD>Invoke TeX on the current region, together with the buffer's header
(<CODE>tex-region</CODE>).
<DT><KBD>C-c C-b</KBD>
<DD>Invoke TeX on the entire current buffer (<CODE>tex-buffer</CODE>).
<DT><KBD>C-c TAB</KBD>
<DD>Invoke BibTeX on the current file (<CODE>tex-bibtex-file</CODE>).
<DT><KBD>C-c C-f</KBD>
<DD>Invoke TeX on the current file (<CODE>tex-file</CODE>).
<DT><KBD>C-c C-l</KBD>
<DD>Recenter the window showing output from the inferior TeX so that
the last line can be seen (<CODE>tex-recenter-output-buffer</CODE>).
<DT><KBD>C-c C-k</KBD>
<DD>Kill the TeX subprocess (<CODE>tex-kill-job</CODE>).
<DT><KBD>C-c C-p</KBD>
<DD>Print the output from the last <KBD>C-c C-r</KBD>, <KBD>C-c C-b</KBD>, or <KBD>C-c
C-f</KBD> command (<CODE>tex-print</CODE>).
<DT><KBD>C-c C-v</KBD>
<DD>Preview the output from the last <KBD>C-c C-r</KBD>, <KBD>C-c C-b</KBD>, or <KBD>C-c
C-f</KBD> command (<CODE>tex-view</CODE>).
<DT><KBD>C-c C-q</KBD>
<DD>Show the printer queue (<CODE>tex-show-print-queue</CODE>).
</DL>
<A NAME="IDX872"></A>
<A NAME="IDX873"></A>
<A NAME="IDX874"></A>
<A NAME="IDX875"></A>
<A NAME="IDX876"></A>
<A NAME="IDX877"></A>
<A NAME="IDX878"></A>
<A NAME="IDX879"></A>
<P>
You can pass the current buffer through an inferior TeX by means of
<KBD>C-c C-b</KBD> (<CODE>tex-buffer</CODE>). The formatted output appears in a
temporary; to print it, type <KBD>C-c C-p</KBD> (<CODE>tex-print</CODE>).
Afterward use <KBD>C-c C-q</KBD> (<CODE>tex-show-print-queue</CODE>) to view the
progress of your output towards being printed. If your terminal has the
ability to display TeX output files, you can preview the output on
the terminal with <KBD>C-c C-v</KBD> (<CODE>tex-view</CODE>).
<A NAME="IDX880"></A>
<A NAME="IDX881"></A>
<P>
You can specify the directory to use for running TeX by setting the
variable <CODE>tex-directory</CODE>. <CODE>"."</CODE> is the default value. If
your environment variable <CODE>TEXINPUTS</CODE> contains relative directory
names, or if your files contains <SAMP>`\input'</SAMP> commands with relative
file names, then <CODE>tex-directory</CODE> <EM>must</EM> be <CODE>"."</CODE> or you
will get the wrong results. Otherwise, it is safe to specify some other
directory, such as <TT>`/tmp'</TT>.
<A NAME="IDX882"></A>
<A NAME="IDX883"></A>
<A NAME="IDX884"></A>
<A NAME="IDX885"></A>
<A NAME="IDX886"></A>
<A NAME="IDX887"></A>
<P>
If you want to specify which shell commands are used in the inferior TeX,
you can do so by setting the values of the variables <CODE>tex-run-command</CODE>,
<CODE>latex-run-command</CODE>, <CODE>slitex-run-command</CODE>,
<CODE>tex-dvi-print-command</CODE>, <CODE>tex-dvi-view-command</CODE>, and
<CODE>tex-show-queue-command</CODE>. You <EM>must</EM> set the value of
<CODE>tex-dvi-view-command</CODE> for your particular terminal; this variable
has no default value. The other variables have default values that may
(or may not) be appropriate for your system.
<P>
Normally, the file name given to these commands comes at the end of
the command string; for example, <SAMP>`latex <VAR>filename</VAR>'</SAMP>. In some
cases, however, the file name needs to be embedded in the command; an
example is when you need to provide the file name as an argument to one
command whose output is piped to another. You can specify where to put
the file name with <SAMP>`*'</SAMP> in the command string. For example,
<P>
<PRE>
(setq tex-dvi-print-command "dvips -f * | lpr")
</PRE>
<A NAME="IDX888"></A>
<A NAME="IDX889"></A>
<A NAME="IDX890"></A>
<A NAME="IDX891"></A>
<P>
The terminal output from TeX, including any error messages, appears
in a buffer called <SAMP>`*tex-shell*'</SAMP>. If TeX gets an error, you can
switch to this buffer and feed it input (this works as in Shell mode;
see section <A HREF="emacs_34.html#SEC316">Interactive Inferior Shell</A>). Without switching to this buffer you can
scroll it so that its last line is visible by typing <KBD>C-c
C-l</KBD>.
<P>
Type <KBD>C-c C-k</KBD> (<CODE>tex-kill-job</CODE>) to kill the TeX process if
you see that its output is no longer useful. Using <KBD>C-c C-b</KBD> or
<KBD>C-c C-r</KBD> also kills any TeX process still running.<A NAME="IDX892"></A>
<A NAME="IDX893"></A>
<P>
You can also pass an arbitrary region through an inferior TeX by typing
<KBD>C-c C-r</KBD> (<CODE>tex-region</CODE>). This is tricky, however, because most files
of TeX input contain commands at the beginning to set parameters and
define macros, without which no later part of the file will format
correctly. To solve this problem, <KBD>C-c C-r</KBD> allows you to designate a
part of the file as containing essential commands; it is included before
the specified region as part of the input to TeX. The designated part
of the file is called the <DFN>header</DFN>.
<A NAME="IDX894"></A>
<P>
To indicate the bounds of the header in Plain TeX mode, you insert two
special strings in the file. Insert <SAMP>`%**start of header'</SAMP> before the
header, and <SAMP>`%**end of header'</SAMP> after it. Each string must appear
entirely on one line, but there may be other text on the line before or
after. The lines containing the two strings are included in the header.
If <SAMP>`%**start of header'</SAMP> does not appear within the first 100 lines of
the buffer, <KBD>C-c C-r</KBD> assumes that there is no header.
<P>
In LaTeX mode, the header begins with <SAMP>`\documentstyle'</SAMP> and ends
with <SAMP>`\begin{document}'</SAMP>. These are commands that LaTeX requires
you to use in any case, so nothing special needs to be done to identify the
header.
<A NAME="IDX895"></A>
<A NAME="IDX896"></A>
<P>
The commands (<CODE>tex-buffer</CODE>) and (<CODE>tex-region</CODE>) do all of their
work in a temporary directory, and do not have available any of the auxiliary
files needed by TeX for cross-references; these commands are generally
not suitable for running the final copy in which all of the cross-references
need to be correct. When you want the auxiliary files, use <KBD>C-c C-f</KBD>
(<CODE>tex-file</CODE>) which runs TeX on the current buffer's file, in that
file's directory. Before TeX runs, you will be asked about saving
any modified buffers. Generally, you need to use (<CODE>tex-file</CODE>)
twice to get cross-references correct.
<A NAME="IDX897"></A>
<A NAME="IDX898"></A>
<A NAME="IDX899"></A>
<P>
For LaTeX files, you can use BibTeX to process the auxiliary
file for the current buffer's file. BibTeX looks up bibliographic
citations in a data base and prepares the cited references for the
bibliography section. The command <KBD>C-c TAB</KBD>
(<CODE>tex-bibtex-file</CODE>) runs the shell command
(<CODE>tex-bibtex-command</CODE>) to produce a <SAMP>`.bbl'</SAMP> file for the
current buffer's file. Generally, you need to do <KBD>C-c C-f</KBD>
(<CODE>tex-file</CODE>) once to generate the <SAMP>`.aux'</SAMP> file, then do
<KBD>C-c TAB</KBD> (<CODE>tex-bibtex-file</CODE>), and then repeat <KBD>C-c C-f</KBD>
(<CODE>tex-file</CODE>) twice more to get the cross-references correct.
<A NAME="IDX900"></A>
<A NAME="IDX901"></A>
<A NAME="IDX902"></A>
<A NAME="IDX903"></A>
<A NAME="IDX904"></A>
<P>
Entering any kind of TeX mode runs the hooks <CODE>text-mode-hook</CODE>
and <CODE>tex-mode-hook</CODE>. Then it runs either
<CODE>plain-tex-mode-hook</CODE> or <CODE>latex-mode-hook</CODE>, whichever is
appropriate. For SliTeX files, it calls <CODE>slitex-mode-hook</CODE>.
Starting the TeX shell runs the hook <CODE>tex-shell-hook</CODE>.
See section <A HREF="emacs_35.html#SEC337">Hooks</A>.
<P>
<H3><A NAME="SEC174" HREF="emacs_toc.html#SEC174">Unix TeX Distribution</A></H3>
<P>
TeX for Unix systems can be obtained from the University of Washington
for a distribution fee.
<P>
To order a full distribution, send $200.00 for a 1/2-inch 9-track 1600
bpi (tar or cpio) tape reel, or $210.00 for a 1/4-inch 4-track QIC-24
(tar or cpio) cartridge, payable to the University of Washington to:
<P>
<PRE>
Northwest Computing Support Center
DR-10, Thomson Hall 35
University of Washington
Seattle, Washington 98195
</PRE>
<P>
Purchase orders are acceptable, but there is an extra charge of
$10.00, to pay for processing charges.
<P>
For overseas orders please add $20.00 to the base cost for shipment via
air parcel post, or $30.00 for shipment via courier.
<P>
The normal distribution is a tar tape, blocked 20, 1600 bpi, on an
industry standard 2400 foot half-inch reel. The physical format for
the 1/4 inch streamer cartridges uses QIC-11, 8000 bpi, 4-track
serpentine recording for the SUN. Also, System V tapes can be written
in cpio format, blocked 5120 bytes, ASCII headers.
<P>
<H2><A NAME="SEC175" HREF="emacs_toc.html#SEC175">Nroff Mode</A></H2>
<A NAME="IDX905"></A>
<A NAME="IDX906"></A>
<P>
Nroff mode is a mode like Text mode but modified to handle nroff commands
present in the text. Invoke <KBD>M-x nroff-mode</KBD> to enter this mode. It
differs from Text mode in only a few ways. All nroff command lines are
considered paragraph separators, so that filling will never garble the
nroff commands. Pages are separated by <SAMP>`.bp'</SAMP> commands. Comments
start with backslash-doublequote. Also, three special commands are
provided that are not in Text mode:
<A NAME="IDX907"></A>
<A NAME="IDX908"></A>
<A NAME="IDX909"></A>
<A NAME="IDX910"></A>
<A NAME="IDX911"></A>
<A NAME="IDX912"></A>
<P>
<DL COMPACT>
<DT><KBD>M-n</KBD>
<DD>Move to the beginning of the next line that isn't an nroff command
(<CODE>forward-text-line</CODE>). An argument is a repeat count.
<DT><KBD>M-p</KBD>
<DD>Like <KBD>M-n</KBD> but move up (<CODE>backward-text-line</CODE>).
<DT><KBD>M-?</KBD>
<DD>Prints in the echo area the number of text lines (lines that are not
nroff commands) in the region (<CODE>count-text-lines</CODE>).
</DL>
<A NAME="IDX913"></A>
<P>
The other feature of Nroff mode is that you can turn on Electric Nroff
mode. This is a minor mode that you can turn on or off with <KBD>M-x
electric-nroff-mode</KBD> (see section <A HREF="emacs_35.html#SEC333">Minor Modes</A>). When the mode is on, each
time you use <KBD>RET</KBD> to end a line that contains an nroff command that
opens a kind of grouping, the matching nroff command to close that
grouping is automatically inserted on the following line. For example,
if you are at the beginning of a line and type <KBD>. ( b <KBD>RET</KBD></KBD>,
this inserts the matching command <SAMP>`.)b'</SAMP> on a new line following
point.
<A NAME="IDX914"></A>
<P>
Entering Nroff mode runs the hook <CODE>text-mode-hook</CODE>, followed by
the hook <CODE>nroff-mode-hook</CODE> (see section <A HREF="emacs_35.html#SEC337">Hooks</A>).
<P>Go to the <A HREF="emacs_24.html">previous</A>, <A HREF="emacs_26.html">next</A> section.<P>
| Java |
SELECT
id_registrazione,
dat_registrazione,
des_registrazione
FROM contabilita.registrazione
WHERE id_cliente = %id_cliente%
AND num_fattura = '%num_fattura%'
AND dat_registrazione = '%dat_registrazione%'
AND extract(year from dat_registrazione) = extract(year from current_date) | Java |
/*
* MATRIX COMPUTATION FOR RESERVATION BASED SYSTEMS
*
* Copyright (C) 2013, University of Trento
* Authors: Luigi Palopoli <palopoli@disi.unitn.it>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#ifndef MATRIX_HPP
#define MATRIX_HPP
double matrix_prob_ts(int i, int j, int q, const cdf &p,
const pmf &u);
double matrix_prob_ts_compressed(int i, int j, int q, const cdf &p,
const pmf &u);
void compute_matrixes(const MatrixXd & mat, int dim, MatrixXd & B, MatrixXd & A0,
MatrixXd & A1, MatrixXd & A2);
#endif
| Java |
from __future__ import print_function
"""
Deprecated. Use ``update-tld-names`` command instead.
"""
__title__ = 'tld.update'
__author__ = 'Artur Barseghyan'
__copyright__ = '2013-2015 Artur Barseghyan'
__license__ = 'GPL 2.0/LGPL 2.1'
from tld.utils import update_tld_names
_ = lambda x: x
if __name__ == '__main__':
update_tld_names()
print(_("Local TLD names file has been successfully updated!"))
| Java |
<?php
/**
* PESCMS for PHP 5.6+
*
* Copyright (c) 2015 PESCMS (http://www.pescms.com)
*
* For the full copyright and license information, please view
* the file LICENSE.md that was distributed with this source code.
*/
namespace App\Team\GET;
class Project extends Content{
/**
* 项目数据分析
*/
public function analyze(){
$param = [];
if(empty($_GET['begin']) && empty($_GET['end']) ){
$param['begin'] = time() - 86400 * 30;
$param['end'] = time();
}else{
$param['begin'] = strtotime(self::g('begin'). '00:00:00');
$param['end'] = strtotime(self::g('end'). '23:59:59');
}
$result = self::db('project AS p')
->field('p.project_id AS id, p.project_title AS name, t.task_status, COUNT(t.task_status) AS total ')
->join("{$this->prefix}task AS t ON t.task_project_id = p.project_id")
->where("t.task_submit_time BETWEEN :begin AND :end")
->group('p.project_id, t.task_status')
->select($param);
$list = [];
$project = \Model\Content::listContent(['table' => 'project', 'order' => 'project_listsort ASC, project_id DESC']);
foreach ($project as $item){
$list[$item['project_id']]['name'] = $item['project_title'];
}
if(!empty($result)){
foreach ($result as $value){
if(empty($list[$value['id']]['total'])){
$list[$value['id']]['total'] = 0;
}
$list[$value['id']]['total'] += $value['total'];
$list[$value['id']]['task_status'][$value['task_status']] = $value['total'];
}
}
$this->assign('title', '项目数据分析');
$this->assign('list', $list);
$this->layout('User/User_analyze');
}
} | Java |
<?php
/**
* ---------------------------------------------------------------------
* GLPI - Gestionnaire Libre de Parc Informatique
* Copyright (C) 2015-2017 Teclib' and contributors.
*
* http://glpi-project.org
*
* based on GLPI - Gestionnaire Libre de Parc Informatique
* Copyright (C) 2003-2014 by the INDEPNET Development Team.
*
* ---------------------------------------------------------------------
*
* LICENSE
*
* This file is part of GLPI.
*
* GLPI 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.
*
* GLPI 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 GLPI. If not, see <http://www.gnu.org/licenses/>.
* ---------------------------------------------------------------------
*/
/** @file
* @brief
*/
include ('../inc/includes.php');
Session::checkRight("sla", READ);
Html::header(SLA::getTypeName(Session::getPluralNumber()), $_SERVER['PHP_SELF'], "config", "sla");
Search::show('SLA');
Html::footer();
| Java |
/* $Id: mpnotification-r0drv-solaris.c $ */
/** @file
* IPRT - Multiprocessor Event Notifications, Ring-0 Driver, Solaris.
*/
/*
* Copyright (C) 2008-2015 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
/*********************************************************************************************************************************
* Header Files *
*********************************************************************************************************************************/
#include "the-solaris-kernel.h"
#include "internal/iprt.h"
#include <iprt/err.h>
#include <iprt/mp.h>
#include <iprt/cpuset.h>
#include <iprt/string.h>
#include <iprt/thread.h>
#include "r0drv/mp-r0drv.h"
/*********************************************************************************************************************************
* Global Variables *
*********************************************************************************************************************************/
/** Whether CPUs are being watched or not. */
static volatile bool g_fSolCpuWatch = false;
/** Set of online cpus that is maintained by the MP callback.
* This avoids locking issues querying the set from the kernel as well as
* eliminating any uncertainty regarding the online status during the
* callback. */
RTCPUSET g_rtMpSolCpuSet;
/**
* Internal solaris representation for watching CPUs.
*/
typedef struct RTMPSOLWATCHCPUS
{
/** Function pointer to Mp worker. */
PFNRTMPWORKER pfnWorker;
/** Argument to pass to the Mp worker. */
void *pvArg;
} RTMPSOLWATCHCPUS;
typedef RTMPSOLWATCHCPUS *PRTMPSOLWATCHCPUS;
/**
* Solaris callback function for Mp event notification.
*
* @returns Solaris error code.
* @param CpuState The current event/state of the CPU.
* @param iCpu Which CPU is this event for.
* @param pvArg Ignored.
*
* @remarks This function assumes index == RTCPUID.
* We may -not- be firing on the CPU going online/offline and called
* with preemption enabled.
*/
static int rtMpNotificationCpuEvent(cpu_setup_t CpuState, int iCpu, void *pvArg)
{
RTMPEVENT enmMpEvent;
/*
* Update our CPU set structures first regardless of whether we've been
* scheduled on the right CPU or not, this is just atomic accounting.
*/
if (CpuState == CPU_ON)
{
enmMpEvent = RTMPEVENT_ONLINE;
RTCpuSetAdd(&g_rtMpSolCpuSet, iCpu);
}
else if (CpuState == CPU_OFF)
{
enmMpEvent = RTMPEVENT_OFFLINE;
RTCpuSetDel(&g_rtMpSolCpuSet, iCpu);
}
else
return 0;
rtMpNotificationDoCallbacks(enmMpEvent, iCpu);
NOREF(pvArg);
return 0;
}
DECLHIDDEN(int) rtR0MpNotificationNativeInit(void)
{
if (ASMAtomicReadBool(&g_fSolCpuWatch) == true)
return VERR_WRONG_ORDER;
/*
* Register the callback building the online cpu set as we do so.
*/
RTCpuSetEmpty(&g_rtMpSolCpuSet);
mutex_enter(&cpu_lock);
register_cpu_setup_func(rtMpNotificationCpuEvent, NULL /* pvArg */);
for (int i = 0; i < (int)RTMpGetCount(); ++i)
if (cpu_is_online(cpu[i]))
rtMpNotificationCpuEvent(CPU_ON, i, NULL /* pvArg */);
ASMAtomicWriteBool(&g_fSolCpuWatch, true);
mutex_exit(&cpu_lock);
return VINF_SUCCESS;
}
DECLHIDDEN(void) rtR0MpNotificationNativeTerm(void)
{
if (ASMAtomicReadBool(&g_fSolCpuWatch) == true)
{
mutex_enter(&cpu_lock);
unregister_cpu_setup_func(rtMpNotificationCpuEvent, NULL /* pvArg */);
ASMAtomicWriteBool(&g_fSolCpuWatch, false);
mutex_exit(&cpu_lock);
}
}
| Java |
<ul class="tw">
<?php foreach ($rows as $id => $row) { ?>
<li><?php print $row; ?></li>
<?php } ?>
</ul> | Java |
(function($) {
function ACFTableField() {
var t = this;
t.version = '1.3.4';
t.param = {};
// DIFFERENT IN ACF VERSION 4 and 5 {
t.param.classes = {
btn_small: 'acf-icon small',
// "acf-icon-plus" becomes "-plus" since ACF Pro Version 5.3.2
btn_add_row: 'acf-icon-plus -plus',
btn_add_col: 'acf-icon-plus -plus',
btn_remove_row: 'acf-icon-minus -minus',
btn_remove_col: 'acf-icon-minus -minus',
};
t.param.htmlbuttons = {
add_row: '<a href="#" class="acf-table-add-row ' + t.param.classes.btn_small + ' ' + t.param.classes.btn_add_row + '"></a>',
remove_row: '<a href="#" class="acf-table-remove-row ' + t.param.classes.btn_small + ' ' + t.param.classes.btn_remove_row + '"></a>',
add_col: '<a href="#" class="acf-table-add-col ' + t.param.classes.btn_small + ' ' + t.param.classes.btn_add_col + '"></a>',
remove_col: '<a href="#" class="acf-table-remove-col ' + t.param.classes.btn_small + ' ' + t.param.classes.btn_remove_row + '"></a>',
};
// }
t.param.htmltable = {
body_row: '<div class="acf-table-body-row">' +
'<div class="acf-table-body-left">' +
t.param.htmlbuttons.add_row +
'<div class="acf-table-body-cont"><!--ph--></div>' +
'</div>' +
'<div class="acf-table-body-right">' +
t.param.htmlbuttons.remove_row +
'</div>' +
'</div>',
top_cell: '<div class="acf-table-top-cell" data-colparam="">' +
t.param.htmlbuttons.add_col +
'<div class="acf-table-top-cont"><!--ph--></div>' +
'</div>',
header_cell: '<div class="acf-table-header-cell">' +
'<div class="acf-table-header-cont"><!--ph--></div>' +
'</div>',
body_cell: '<div class="acf-table-body-cell">' +
'<div class="acf-table-body-cont"><!--ph--></div>' +
'</div>',
bottom_cell: '<div class="acf-table-bottom-cell">' +
t.param.htmlbuttons.remove_col +
'</div>',
table: '<div class="acf-table-wrap">' +
'<div class="acf-table-table">' + // acf-table-hide-header acf-table-hide-left acf-table-hide-top
'<div class="acf-table-top-row">' +
'<div class="acf-table-top-left">' +
t.param.htmlbuttons.add_col +
'</div>' +
'<div class="acf-table-top-right"></div>' +
'</div>' +
'<div class="acf-table-header-row acf-table-header-hide-off">' +
'<div class="acf-table-header-left">' +
t.param.htmlbuttons.add_row +
'</div>' +
'<div class="acf-table-header-right"></div>' +
'</div>' +
'<div class="acf-table-bottom-row">' +
'<div class="acf-table-bottom-left"></div>' +
'<div class="acf-table-bottom-right"></div>' +
'</div>' +
'</div>' +
'</div>',
};
t.param.htmleditor = '<div class="acf-table-cell-editor">' +
'<textarea name="acf-table-cell-editor-textarea" class="acf-table-cell-editor-textarea"></textarea>' +
'</div>';
t.obj = {
body: $( 'body' ),
};
t.var = {
ajax: false,
};
t.state = {
'current_cell_obj': false,
'cell_editor_cell': false,
'cell_editor_last_keycode': false
};
t.init = function() {
t.init_workflow();
};
t.init_workflow = function() {
t.each_table();
t.table_add_col_event();
t.table_remove_col();
t.table_add_row_event();
t.table_remove_row();
t.cell_editor();
t.cell_editor_tab_navigation();
t.prevent_cell_links();
t.sortable_row();
t.sortable_col();
t.ui_event_use_header();
t.ui_event_caption();
t.ui_event_new_flex_field();
t.ui_event_change_location_rule();
t.ui_event_ajax();
};
t.ui_event_ajax = function() {
$( document ).ajaxComplete( function( event ) {
t.each_table();
});
}
t.ui_event_change_location_rule = function() {
t.obj.body.on( 'change', '[name="post_category[]"], [name="post_format"], [name="page_template"], [name="parent_id"], [name="role"], [name^="tax_input"]', function() {
var interval = setInterval( function() {
var table_fields = $( '.field_type-table' );
if ( table_fields.length > 0 ) {
t.each_table();
clearInterval( interval );
}
}, 100 );
} );
};
t.each_table = function( ) {
$( '.acf-field-table .acf-table-root' ).not( '.acf-table-rendered' ).each( function() {
var p = {};
p.obj_root = $( this ),
table = p.obj_root.find( '.acf-table-wrap' );
if ( table.length > 0 ) {
return;
}
p.obj_root.addClass( 'acf-table-rendered' );
t.data_get( p );
t.data_default( p );
t.field_options_get( p );
t.table_render( p );
t.misc_render( p );
if ( typeof p.data.b[ 1 ] === 'undefined' && typeof p.data.b[ 0 ][ 1 ] === 'undefined' && p.data.b[ 0 ][ 0 ].c === '' ) {
p.obj_root.find( '.acf-table-remove-col' ).hide(),
p.obj_root.find( '.acf-table-remove-row' ).hide();
}
} );
};
t.field_options_get = function( p ) {
try {
p.field_options = $.parseJSON( decodeURIComponent( p.obj_root.find( '[data-field-options]' ).data( 'field-options' ) ) );
}
catch (e) {
p.field_options = {
use_header: 2
};
console.log( 'The tablefield options value is not a valid JSON string:', decodeURIComponent( p.obj_root.find( '[data-field-options]' ).data( 'field-options' ) ) );
console.log( 'The parsing error:', e );
}
};
t.ui_event_use_header = function() {
// HEADER: SELECT FIELD ACTIONS {
t.obj.body.on( 'change', '.acf-table-fc-opt-use-header', function() {
var that = $( this ),
p = {};
p.obj_root = that.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
t.data_get( p );
t.data_default( p );
if ( that.val() === '1' ) {
p.obj_table.removeClass( 'acf-table-hide-header' );
p.data.p.o.uh = 1;
t.update_table_data_field( p );
}
else {
p.obj_table.addClass( 'acf-table-hide-header' );
p.data.p.o.uh = 0;
t.update_table_data_field( p );
}
} );
// }
};
t.ui_event_caption = function() {
// CAPTION: INPUT FIELD ACTIONS {
t.obj.body.on( 'change', '.acf-table-fc-opt-caption', function() {
var that = $( this ),
p = {};
p.obj_root = that.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
t.data_get( p );
t.data_default( p );
p.data.p.ca = that.val();
t.update_table_data_field( p );
} );
// }
};
t.ui_event_new_flex_field = function() {
t.obj.body.on( 'click', '.acf-fc-popup', function() {
// SORTABLE {
$( '.acf-table-table' )
.sortable('destroy')
.unbind();
window.setTimeout( function() {
t.sortable_row();
}, 300 );
// }
} );
};
t.data_get = function( p ) {
// DATA FROM FIELD {
var val = p.obj_root.find( 'input.table' ).val();
p.data = false;
// CHECK FIELD CONTEXT {
if ( p.obj_root.closest( '.acf-fields' ).hasClass( 'acf-block-fields' ) ) {
p.field_context = 'block';
}
else {
p.field_context = 'box';
}
// }
if ( val !== '' ) {
try {
if ( p.field_context === 'box' ) {
p.data = $.parseJSON( decodeURIComponent( val.replace(/\+/g, '%20') ) );
}
if ( p.field_context === 'block' ) {
p.data = $.parseJSON( decodeURIComponent( decodeURIComponent( val.replace(/\+/g, '%20') ) ) );
}
}
catch (e) {
if ( p.field_context === 'box' ) {
console.log( 'The tablefield value is not a valid JSON string:', decodeURIComponent( val.replace(/\+/g, '%20') ) );
console.log( 'The parsing error:', e );
}
if ( p.field_context === 'block' ) {
console.log( 'The tablefield value is not a valid JSON string:', decodeURIComponent( decodeURIComponent( val.replace(/\+/g, '%20') ) ) );
console.log( 'The tablefield value is not a valid JSON string:', decodeURIComponent( decodeURIComponent( decodeURIComponent( val.replace(/\+/g, '%20') ) ) ) );
console.log( 'The parsing error:', e );
}
}
}
return p.data;
// }
};
t.data_default = function( p ) {
// DEFINE DEFAULT DATA {
p.data_defaults = {
acftf: {
v: t.version,
},
p: {
o: {
uh: 0, // use header
},
ca: '', // caption content
},
// from data-colparam
c: [
{
c: '',
},
],
// header
h: [
{
c: '',
},
],
// body
b: [
[
{
c: '',
},
],
],
};
// }
// MERGE DEFAULT DATA {
if ( p.data ) {
if ( typeof p.data.b === 'array' ) {
$.extend( true, p.data, p.data_defaults );
}
}
else {
p.data = p.data_defaults;
}
// }
};
t.table_render = function( p ) {
// TABLE HTML MAIN {
p.obj_root.find( '.acf-table-wrap' ).remove();
p.obj_root.append( t.param.htmltable.table );
// }
// TABLE GET OBJECTS {
p.obj_table = p.obj_root.find( '.acf-table-table' );
p.obj_top_row = p.obj_root.find( '.acf-table-top-row' ),
p.obj_top_insert = p.obj_top_row.find( '.acf-table-top-right' ),
p.obj_header_row = p.obj_root.find( '.acf-table-header-row' ),
p.obj_header_insert = p.obj_header_row.find( '.acf-table-header-right' ),
p.obj_bottom_row = p.obj_root.find( '.acf-table-bottom-row' ),
p.obj_bottom_insert = p.obj_bottom_row.find( '.acf-table-bottom-right' );
// }
// TOP CELLS {
if ( p.data.c ) {
for ( i in p.data.c ) {
p.obj_top_insert.before( t.param.htmltable.top_cell );
}
}
t.table_top_labels( p );
// }
// HEADER CELLS {
if ( p.data.h ) {
for ( i in p.data.h ) {
p.obj_header_insert.before( t.param.htmltable.header_cell.replace( '<!--ph-->', p.data.h[ i ].c.replace( /xxx"/g, '"' ) ) );
}
}
// }
// BODY ROWS {
if ( p.data.b ) {
for ( i in p.data.b ) {
p.obj_bottom_row.before( t.param.htmltable.body_row.replace( '<!--ph-->', parseInt(i) + 1 ) );
}
}
// }
// BODY ROWS CELLS {
var body_rows = p.obj_root.find( '.acf-table-body-row'),
row_i = 0;
if ( body_rows ) {
body_rows.each( function() {
var body_row = $( this ),
row_insert = body_row.find( '.acf-table-body-right' );
for( i in p.data.b[ row_i ] ) {
row_insert.before( t.param.htmltable.body_cell.replace( '<!--ph-->', p.data.b[ row_i ][ i ].c.replace( /xxx"/g, '"' ) ) );
}
row_i = row_i + 1
} );
}
// }
// TABLE BOTTOM {
if ( p.data.c ) {
for ( i in p.data.c ) {
p.obj_bottom_insert.before( t.param.htmltable.bottom_cell );
}
}
// }
};
t.misc_render = function( p ) {
t.init_option_use_header( p );
t.init_option_caption( p );
};
t.init_option_use_header = function( p ) {
// VARS {
var v = {};
v.obj_use_header = p.obj_root.find( '.acf-table-fc-opt-use-header' );
// }
// HEADER {
// HEADER: FIELD OPTIONS, THAT AFFECTS DATA {
// HEADER IS NOT ALLOWED
if ( p.field_options.use_header === 2 ) {
p.obj_table.addClass( 'acf-table-hide-header' );
p.data.p.o.uh = 0;
t.update_table_data_field( p );
}
// HEADER IS REQUIRED
if ( p.field_options.use_header === 1 ) {
p.data.p.o.uh = 1;
t.update_table_data_field( p );
}
// }
// HEADER: SET CHECKBOX STATUS {
if ( p.data.p.o.uh === 1 ) {
v.obj_use_header.val( '1' );
}
if ( p.data.p.o.uh === 0 ) {
v.obj_use_header.val( '0' );
}
// }
// HEADER: SET HEADER VISIBILITY {
if ( p.data.p.o.uh === 1 ) {
p.obj_table.removeClass( 'acf-table-hide-header' );
}
if ( p.data.p.o.uh === 0 ) {
p.obj_table.addClass( 'acf-table-hide-header' );
}
// }
// }
};
t.init_option_caption = function( p ) {
if (
typeof p.field_options.use_caption !== 'number' ||
p.field_options.use_caption === 2
) {
return;
}
// VARS {
var v = {};
v.obj_caption = p.obj_root.find( '.acf-table-fc-opt-caption' );
// }
// SET CAPTION VALUE {
v.obj_caption.val( p.data.p.ca );
// }
};
t.table_add_col_event = function() {
t.obj.body.on( 'click', '.acf-table-add-col', function( e ) {
e.preventDefault();
var that = $( this ),
p = {};
p.obj_col = that.parent();
t.table_add_col( p );
} );
};
t.table_add_col = function( p ) {
// requires
// p.obj_col
var that_index = p.obj_col.index();
p.obj_root = p.obj_col.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
$( p.obj_table.find( '.acf-table-top-row' ).children()[ that_index ] ).after( t.param.htmltable.top_cell.replace( '<!--ph-->', '' ) );
$( p.obj_table.find( '.acf-table-header-row' ).children()[ that_index ] ).after( t.param.htmltable.header_cell.replace( '<!--ph-->', '' ) );
p.obj_table.find( '.acf-table-body-row' ).each( function() {
$( $( this ).children()[ that_index ] ).after( t.param.htmltable.body_cell.replace( '<!--ph-->', '' ) );
} );
$( p.obj_table.find( '.acf-table-bottom-row' ).children()[ that_index ] ).after( t.param.htmltable.bottom_cell.replace( '<!--ph-->', '' ) );
t.table_top_labels( p );
p.obj_table.find( '.acf-table-remove-col' ).show();
p.obj_table.find( '.acf-table-remove-row' ).show();
t.table_build_json( p );
};
t.table_remove_col = function() {
t.obj.body.on( 'click', '.acf-table-remove-col', function( e ) {
e.preventDefault();
var p = {},
that = $( this ),
that_index = that.parent().index(),
obj_rows = undefined,
cols_count = false;
p.obj_root = that.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
p.obj_top = p.obj_root.find( '.acf-table-top-row' );
obj_rows = p.obj_table.find( '.acf-table-body-row' );
cols_count = p.obj_top.find( '.acf-table-top-cell' ).length;
$( p.obj_table.find( '.acf-table-top-row' ).children()[ that_index ] ).remove();
$( p.obj_table.find( '.acf-table-header-row' ).children()[ that_index ] ).remove();
if ( cols_count == 1 ) {
obj_rows.remove();
t.table_add_col( {
obj_col: p.obj_table.find( '.acf-table-top-left' )
} );
t.table_add_row( {
obj_row: p.obj_table.find( '.acf-table-header-row' )
} );
p.obj_table.find( '.acf-table-remove-col' ).hide();
p.obj_table.find( '.acf-table-remove-row' ).hide();
}
else {
obj_rows.each( function() {
$( $( this ).children()[ that_index ] ).remove();
} );
}
$( p.obj_table.find( '.acf-table-bottom-row' ).children()[ that_index ] ).remove();
t.table_top_labels( p );
t.table_build_json( p );
} );
};
t.table_add_row_event = function() {
t.obj.body.on( 'click', '.acf-table-add-row', function( e ) {
e.preventDefault();
var that = $( this ),
p = {};
p.obj_row = that.parent().parent();
t.table_add_row( p );
});
};
t.table_add_row = function( p ) {
// requires
// p.obj_row
var that_index = 0,
col_amount = 0,
body_cells_html = '';
p.obj_root = p.obj_row.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
p.obj_table_rows = p.obj_table.children();
col_amount = p.obj_table.find( '.acf-table-top-cell' ).size();
that_index = p.obj_row.index();
for ( i = 0; i < col_amount; i++ ) {
body_cells_html = body_cells_html + t.param.htmltable.body_cell.replace( '<!--ph-->', '' );
}
$( p.obj_table_rows[ that_index ] )
.after( t.param.htmltable.body_row )
.next()
.find('.acf-table-body-left')
.after( body_cells_html );
t.table_left_labels( p );
p.obj_table.find( '.acf-table-remove-col' ).show();
p.obj_table.find( '.acf-table-remove-row' ).show();
t.table_build_json( p );
};
t.table_remove_row = function() {
t.obj.body.on( 'click', '.acf-table-remove-row', function( e ) {
e.preventDefault();
var p = {},
that = $( this ),
rows_count = false;
p.obj_root = that.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
p.obj_rows = p.obj_root.find( '.acf-table-body-row' );
rows_count = p.obj_rows.length;
that.parent().parent().remove();
if ( rows_count == 1 ) {
t.table_add_row( {
obj_row: p.obj_table.find( '.acf-table-header-row' )
} );
p.obj_table.find( '.acf-table-remove-row' ).hide();
}
t.table_left_labels( p );
t.table_build_json( p );
} );
};
t.table_top_labels = function( p ) {
var letter_i_1 = 'A'.charCodeAt( 0 ),
letter_i_2 = 'A'.charCodeAt( 0 ),
use_2 = false;
p.obj_table.find( '.acf-table-top-cont' ).each( function() {
var string = '';
if ( !use_2 ) {
string = String.fromCharCode( letter_i_1 );
if ( letter_i_1 === 'Z'.charCodeAt( 0 ) ) {
letter_i_1 = 'A'.charCodeAt( 0 );
use_2 = true;
}
else {
letter_i_1 = letter_i_1 + 1;
}
}
else {
string = String.fromCharCode( letter_i_1 ) + String.fromCharCode( letter_i_2 );
if ( letter_i_2 === 'Z'.charCodeAt( 0 ) ) {
letter_i_1 = letter_i_1 + 1;
letter_i_2 = 'A'.charCodeAt( 0 );
}
else {
letter_i_2 = letter_i_2 + 1;
}
}
$( this ).text( string );
} );
};
t.table_left_labels = function( p ) {
var i = 0;
p.obj_table.find( '.acf-table-body-left' ).each( function() {
i = i + 1;
$( this ).find( '.acf-table-body-cont' ).text( i );
} );
};
t.table_build_json = function( p ) {
var i = 0,
i2 = 0;
p.data = t.data_get( p );
t.data_default( p );
p.data.c = [];
p.data.h = [];
p.data.b = [];
// TOP {
i = 0;
p.obj_table.find( '.acf-table-top-cont' ).each( function() {
p.data.c[ i ] = {};
p.data.c[ i ].p = $( this ).parent().data( 'colparam' );
i = i + 1;
} );
// }
// HEADER {
i = 0;
p.obj_table.find( '.acf-table-header-cont' ).each( function() {
p.data.h[ i ] = {};
p.data.h[ i ].c = $( this ).html();
i = i + 1;
} );
// }
// BODY {
i = 0;
i2 = 0;
p.obj_table.find( '.acf-table-body-row' ).each( function() {
p.data.b[ i ] = [];
$( this ).find( '.acf-table-body-cell .acf-table-body-cont' ).each( function() {
p.data.b[ i ][ i2 ] = {};
p.data.b[ i ][ i2 ].c = $( this ).html();
i2 = i2 + 1;
} );
i2 = 0;
i = i + 1;
} );
// }
// UPDATE INPUT WITH NEW DATA {
t.update_table_data_field( p );
// }
};
t.update_table_data_field = function( p ) {
// UPDATE INPUT WITH NEW DATA {
p.data = t.update_table_data_version( p.data );
// makes json string from data object
var data = JSON.stringify( p.data );
// adds backslash to all \" in JSON string because encodeURIComponent() strippes backslashes
data.replace( /\\"/g, '\\"' );
// encodes the JSON string to URI component, the format, the JSON string is saved to the database
data = encodeURIComponent( data )
p.obj_root.find( 'input.table' ).val( data );
t.field_changed( p );
// }
};
t.update_table_data_version = function( data ) {
if ( typeof data.acftf === 'undefined' ) {
data.acftf = {};
}
data.acftf.v = t.version;
return data;
}
t.cell_editor = function() {
t.obj.body.on( 'click', '.acf-table-body-cell, .acf-table-header-cell', function( e ) {
e.stopImmediatePropagation();
t.cell_editor_save();
var that = $( this );
t.cell_editor_add_editor({
'that': that
});
} );
t.obj.body.on( 'click', '.acf-table-cell-editor-textarea', function( e ) {
e.stopImmediatePropagation();
} );
t.obj.body.on( 'click', function( e ) {
t.cell_editor_save();
} );
};
t.cell_editor_add_editor = function( p ) {
var defaults = {
'that': false
};
p = $.extend( true, defaults, p );
if ( p['that'] ) {
var that_val = p['that'].find( '.acf-table-body-cont, .acf-table-header-cont' ).html();
t.state.current_cell_obj = p['that'];
t.state.cell_editor_is_open = true;
p['that'].prepend( t.param.htmleditor ).find( '.acf-table-cell-editor-textarea' ).html( that_val ).focus();
}
};
t.get_next_table_cell = function( p ) {
var defaults = {
'key': false
};
p = $.extend( true, defaults, p );
// next cell of current row
var next_cell = t.state.current_cell_obj
.next( '.acf-table-body-cell, .acf-table-header-cell' );
// else if get next row
if ( next_cell.length === 0 ) {
next_cell = t.state.current_cell_obj
.parent()
.next( '.acf-table-body-row' )
.find( '.acf-table-body-cell')
.first();
}
// if next row, get first cell of that row
if ( next_cell.length !== 0 ) {
t.state.current_cell_obj = next_cell;
}
else {
t.state.current_cell_obj = false;
}
};
t.get_prev_table_cell = function( p ) {
var defaults = {
'key': false
};
p = $.extend( true, defaults, p );
// prev cell of current row
var table_obj = t.state.current_cell_obj.closest( '.acf-table-table' ),
no_header = table_obj.hasClass( 'acf-table-hide-header' );
prev_cell = t.state.current_cell_obj
.prev( '.acf-table-body-cell, .acf-table-header-cell' );
// else if get prev row
if ( prev_cell.length === 0 ) {
var row_selectors = [ '.acf-table-body-row' ];
// prevents going to header cell if table header is hidden
if ( no_header === false ) {
row_selectors.push( '.acf-table-header-row' );
}
prev_cell = t.state.current_cell_obj
.parent()
.prev( row_selectors.join( ',' ) )
.find( '.acf-table-body-cell, .acf-table-header-cell' )
.last();
}
// if next row, get first cell of that row
if ( prev_cell.length !== 0 ) {
t.state.current_cell_obj = prev_cell;
}
else {
t.state.current_cell_obj = false;
}
};
t.cell_editor_save = function() {
var cell_editor = t.obj.body.find( '.acf-table-cell-editor' ),
cell_editor_textarea = cell_editor.find( '.acf-table-cell-editor-textarea' ),
p = {},
cell_editor_val = '';
if ( typeof cell_editor_textarea.val() !== 'undefined' ) {
p.obj_root = cell_editor.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
var cell_editor_val = cell_editor_textarea.val();
// prevent XSS injection
cell_editor_val = cell_editor_val.replace( /\<(script)/ig, '<$1' );
cell_editor_val = cell_editor_val.replace( /\<\/(script)/ig, '</$1' );
cell_editor.next().html( cell_editor_val );
t.table_build_json( p );
cell_editor.remove();
t.state.cell_editor_is_open = false;
p.obj_root.find( '.acf-table-remove-col' ).show(),
p.obj_root.find( '.acf-table-remove-row' ).show();
}
};
t.cell_editor_tab_navigation = function() {
t.obj.body.on( 'keydown', '.acf-table-cell-editor', function( e ) {
var keyCode = e.keyCode || e.which;
if ( keyCode == 9 ) {
e.preventDefault();
t.cell_editor_save();
if ( t.state.cell_editor_last_keycode === 16 ) {
t.get_prev_table_cell();
}
else {
t.get_next_table_cell();
}
t.cell_editor_add_editor({
'that': t.state.current_cell_obj
});
}
t.state.cell_editor_last_keycode = keyCode;
});
};
t.prevent_cell_links = function() {
t.obj.body.on( 'click', '.acf-table-body-cont a, .acf-table-header-cont a', function( e ) {
e.preventDefault();
} );
};
t.sortable_fix_width = function(e, ui) {
ui.children().each( function() {
var that = $( this );
that.width( that.width() );
} );
return ui;
};
t.sortable_row = function() {
var param = {
axis: 'y',
items: '> .acf-table-body-row',
containment: 'parent',
handle: '.acf-table-body-left',
helper: t.sortable_fix_width,
update: function( event, ui ) {
var p = {};
p.obj_root = ui.item.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
t.table_left_labels( p );
t.table_build_json( p );
},
};
$( '.acf-table-table' ).sortable( param );
};
t.sortable_col = function() {
var p = {};
p.start_index = 0;
p.end_index = 0;
var param = {
axis: 'x',
items: '> .acf-table-top-cell',
containment: 'parent',
helper: t.sortable_fix_width,
start: function(event, ui) {
p.start_index = ui.item.index();
},
update: function( event, ui ) {
p.end_index = ui.item.index();
p.obj_root = ui.item.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
t.table_top_labels( p );
t.sort_cols( p );
t.table_build_json( p );
},
};
$( '.acf-table-top-row' ).sortable( param );
t.obj.body.on( 'click', '.acf-fc-popup', function() {
$( '.acf-table-top-row' )
.sortable('destroy')
.unbind();
window.setTimeout( function() {
$( '.acf-table-top-row' ).sortable( param );
}, 300 );
} );
};
t.field_changed = function( p ) {
if ( p.field_context === 'block' ) {
p.obj_root.change();
}
};
t.sort_cols = function( p ) {
p.obj_table.find('.acf-table-header-row').each( function() {
p.header_row = $(this),
p.header_row_children = p.header_row.children();
if ( p.end_index < p.start_index ) {
$( p.header_row_children[ p.end_index ] ).before( $( p.header_row_children[ p.start_index ] ) );
}
if ( p.end_index > p.start_index ) {
$( p.header_row_children[ p.end_index ] ).after( $( p.header_row_children[ p.start_index ] ) );
}
} );
p.obj_table.find('.acf-table-body-row').each( function() {
p.body_row = $(this),
p.body_row_children = p.body_row.children();
if ( p.end_index < p.start_index ) {
$( p.body_row_children[ p.end_index ] ).before( $( p.body_row_children[ p.start_index ] ) );
}
if ( p.end_index > p.start_index ) {
$( p.body_row_children[ p.end_index ] ).after( $( p.body_row_children[ p.start_index ] ) );
}
} );
};
t.helper = {
getLength: function( o ) {
var len = o.length ? --o.length : -1;
for (var k in o) {
len++;
}
return len;
},
};
};
var acf_table_field = new ACFTableField();
acf_table_field.init();
})( jQuery );
| Java |
FROM kucing/node:latest
MAINTAINER Ivan <ivan@marsud.id>
RUN npm install -g bower gulp phantomjs eslint node-gyp
WORKDIR /app
| Java |
/*
* minimum data types for MIPS and the Ultra64 RCP
*
* No copyright is intended on this file. :)
*
* To work with features of the RCP hardware, we need at the very least:
* 1. a 64-bit type or a type which can encompass 64-bit operations
* 2. signed and unsigned 32-or-more-bit types (s32, u32)
* 3. signed and unsigned 16-or-more-bit types (s16, u16)
* 4. signed and unsigned 8-or-more-bit types (s8, u8)
*
* This tends to coincide with the regulations of <stdint.h> and even most of
* what is guaranteed by simple preprocessor logic and the C89 standard, so
* the deduction of RCP hardware types will have the following priority:
* 1. compiler implementation of the <stdint.h> extension
* 2. 64-bit ABI detection by the preprocessor
* 3. preprocessor derivation of literal integer interpretation
* 4. the presumption of C89 conformance for 8-, 16-, and 32-bit types
* and the presumption of `long long` support for 64-bit types
*
* In situations where the compiler's implementation chooses to control these
* arbitrary sizes on its own or to exchange portability with C99 compliance,
* the standard types (either built-in or external <stdint.h>) will be preferred.
*/
/*
* Rather than call it "n64_types.h" or "my_stdint.h", the idea is that this
* header should be maintainable to any independent implementation's needs,
* especially in the event that one decides that type requirements should be
* mandated by the user and not permanently merged into the C specifications.
*
* Compilers always have had, always should have, and always will have the
* right to choose whether it is the programmer's job to establish the
* arbitrary sizes they prefer to have or whether the C language should
* be complicated enough to specify additional built-in criteria such as
* this, such that it should be able to depend on a system header for it.
*/
#ifndef _MY_TYPES_H_
#define _MY_TYPES_H_
/*
* Until proven otherwise, there are no standard integer types.
*/
#undef HAVE_STANDARD_INTEGER_TYPES
/*
* an optional facility which could be used as an external alternative to
* deducing minimum-width types (if the compiler agrees to rely on this level
* of the language specifications to have it)
*
* Because no standard system is required to have any exact-width type, the
* C99 enforcement of <stdint.h> is more of an early initiative (as in,
* "better early than late" or "better early than never at all") rather than
* a fully portable resource available or even possible all of the time.
*/
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ < 199901L)
/*
* Something which strictly emphasizes pre-C99 standard compliance likely
* does not have any <stdint.h> that we could include (nor built-in types).
*/
#elif defined(_XBOX) || defined(_XENON)
/*
* Since the Microsoft APIs frequently use `long` instead of `int` to ensure
* a minimum of 32-bit DWORD size, they were forced to propose a "LLP64" ABI.
*/
#define MICROSOFT_ABI
#elif defined(_MSC_VER) && (_MSC_VER < 1600)
/*
* In some better, older versions of MSVC, there often was no <stdint.h>.
* We can still use the built-in MSVC types to create the <stdint.h> types.
*/
#define MICROSOFT_ABI
#else
#include <stdint.h>
#endif
/*
* With or without external or internal support for <stdint.h>, we need to
* confirm the level of support for RCP data types on the Nintendo 64.
*
* We only need minimum-width data types, not exact-width types.
* Systems on which there is no 16- or 32-bit type, for example, can easily
* be accounted for by the code itself using optimizable AND bit-masks.
*/
#if defined(INT8_MIN) && defined(INT8_MAX)
#define HAVE_INT8_EXACT
#endif
#if defined(INT_FAST8_MIN) && defined(INT_FAST8_MAX)
#define HAVE_INT8_FAST
#endif
#if defined(INT_LEAST8_MIN) && defined(INT_LEAST8_MAX)
#define HAVE_INT8_MINIMUM
#endif
#if defined(INT16_MIN) && defined(INT16_MAX)
#define HAVE_INT16_EXACT
#endif
#if defined(INT_FAST16_MIN) && defined(INT_FAST16_MAX)
#define HAVE_INT16_FAST
#endif
#if defined(INT_LEAST16_MIN) && defined(INT_LEAST16_MAX)
#define HAVE_INT16_MINIMUM
#endif
#if defined(INT32_MIN) && defined(INT32_MAX)
#define HAVE_INT32_EXACT
#endif
#if defined(INT_FAST32_MIN) && defined(INT_FAST32_MAX)
#define HAVE_INT32_FAST
#endif
#if defined(INT_LEAST32_MIN) && defined(INT_LEAST32_MAX)
#define HAVE_INT32_MINIMUM
#endif
#if defined(INT64_MIN) && defined(INT64_MAX)
#define HAVE_INT64_EXACT
#endif
#if defined(INT_FAST64_MIN) && defined(INT_FAST64_MAX)
#define HAVE_INT64_FAST
#endif
#if defined(INT_LEAST64_MIN) && defined(INT_LEAST64_MAX)
#define HAVE_INT64_MINIMUM
#endif
#if defined(HAVE_INT8_EXACT)\
|| defined(HAVE_INT8_FAST) \
|| defined(HAVE_INT8_MINIMUM)
#define HAVE_INT8
#endif
#if defined(HAVE_INT16_EXACT)\
|| defined(HAVE_INT16_FAST) \
|| defined(HAVE_INT16_MINIMUM)
#define HAVE_INT16
#endif
#if defined(HAVE_INT32_EXACT)\
|| defined(HAVE_INT32_FAST) \
|| defined(HAVE_INT32_MINIMUM)
#define HAVE_INT32
#endif
#if defined(HAVE_INT64_EXACT)\
|| defined(HAVE_INT64_FAST) \
|| defined(HAVE_INT64_MINIMUM)
#define HAVE_INT64
#endif
/*
* This determines whether or not it is possible to use the evolution of the
* C standards for compiler advice on how to define the types or whether we
* will instead rely on preprocessor logic and ABI detection or C89 rules to
* define each of the types.
*/
#if defined(HAVE_INT8) \
&& defined(HAVE_INT16)\
&& defined(HAVE_INT32)\
&& defined(HAVE_INT64)
#define HAVE_STANDARD_INTEGER_TYPES
#endif
#if defined(HAVE_INT8_EXACT)
typedef int8_t s8;
typedef uint8_t u8;
typedef s8 i8;
#elif defined(HAVE_INT8_FAST)
typedef int_fast8_t s8;
typedef uint_fast8_t u8;
typedef s8 i8;
#elif defined(HAVE_INT8_MINIMUM)
typedef int_least8_t s8;
typedef uint_least8_t u8;
typedef s8 i8;
#elif defined(MICROSOFT_ABI)
typedef signed __int8 s8;
typedef unsigned __int8 u8;
typedef __int8 i8;
#else
typedef signed char s8;
typedef unsigned char u8;
typedef char i8;
#endif
#if defined(HAVE_INT16_EXACT)
typedef int16_t s16;
typedef uint16_t u16;
#elif defined(HAVE_INT16_FAST)
typedef int_fast16_t s16;
typedef uint_fast16_t u16;
#elif defined(HAVE_INT16_MINIMUM)
typedef int_least16_t s16;
typedef uint_least16_t u16;
#elif defined(MICROSOFT_ABI)
typedef signed __int16 s16;
typedef unsigned __int16 u16;
#else
typedef signed short s16;
typedef unsigned short u16;
#endif
#if defined(HAVE_INT32_EXACT)
typedef int32_t s32;
typedef uint32_t u32;
#elif defined(HAVE_INT32_FAST)
typedef int_fast32_t s32;
typedef uint_fast32_t u32;
#elif defined(HAVE_INT32_MINIMUM)
typedef int_least32_t s32;
typedef uint_least32_t u32;
#elif defined(MICROSOFT_ABI)
typedef signed __int32 s32;
typedef unsigned __int32 u32;
#elif !defined(__LP64__) && (0xFFFFFFFFL < 0xFFFFFFFFUL)
typedef signed long s32;
typedef unsigned long u32;
#else
typedef signed int s32;
typedef unsigned int u32;
#endif
#if defined(HAVE_INT64_EXACT)
typedef int64_t s64;
typedef uint64_t u64;
#elif defined(HAVE_INT64_FAST)
typedef int_fast64_t s64;
typedef uint_fast64_t u64;
#elif defined(HAVE_INT64_MINIMUM)
typedef int_least64_t s64;
typedef uint_least64_t u64;
#elif defined(MICROSOFT_ABI)
typedef signed __int64 s64;
typedef unsigned __int64 u64;
#elif defined(__LP64__) && (0x00000000FFFFFFFFUL < ~0UL)
typedef signed long s64;
typedef unsigned long u64;
#else
typedef signed long long s64;
typedef unsigned long long u64;
#endif
/*
* Although most types are signed by default, using `int' instead of `signed
* int' and `i32' instead of `s32' can be preferable to denote cases where
* the signedness of something operated on is irrelevant to the algorithm.
*/
typedef s16 i16;
typedef s32 i32;
typedef s64 i64;
/*
* If <stdint.h> was unavailable or not included (should be included before
* "my_types.h" if it is ever to be included), then perhaps this is the
* right opportunity to try defining the <stdint.h> types ourselves.
*
* Due to sole popularity, code can sometimes be easier to read when saying
* things like "int8_t" instead of "i8", just because more people are more
* likely to understand the <stdint.h> type names in generic C code. To be
* as neutral as possible, people will have every right to sometimes prefer
* saying "uint32_t" instead of "u32" for the sake of modern standards.
*
* The below macro just means whether or not we had access to <stdint.h>
* material to deduce any of our 8-, 16-, 32-, or 64-bit type definitions.
*/
#ifndef HAVE_STANDARD_INTEGER_TYPES
typedef s8 int8_t;
typedef u8 uint8_t;
typedef s16 int16_t;
typedef u16 uint16_t;
typedef s32 int32_t;
typedef u32 uint32_t;
typedef s64 int64_t;
typedef u64 uint64_t;
#define HAVE_STANDARD_INTEGER_TYPES
#endif
/*
* Single- and double-precision floating-point data types have a little less
* room for maintenance across different CPU processors, as the C standard
* just provides `float' and `[long] double'. However, if we are going to
* need 32- and 64-bit floating-point precision (which MIPS emulation does
* require), then it could be nice to have these names just to be consistent.
*/
typedef float f32;
typedef double f64;
/*
* Pointer types, serving as the memory reference address to the actual type.
* I thought this was useful to have due to the various reasons for declaring
* or using variable pointers in various styles and complex scenarios.
* ex) i32* pointer;
* ex) i32 * pointer;
* ex) i32 *a, *b, *c;
* neutral: `pi32 pointer;' or `pi32 a, b, c;'
*/
typedef i8* pi8;
typedef i16* pi16;
typedef i32* pi32;
typedef i64* pi64;
typedef s8* ps8;
typedef s16* ps16;
typedef s32* ps32;
typedef s64* ps64;
typedef u8* pu8;
typedef u16* pu16;
typedef u32* pu32;
typedef u64* pu64;
typedef f32* pf32;
typedef f64* pf64;
typedef void* p_void;
typedef void(*p_func)(void);
/*
* helper macros with exporting functions for shared objects or dynamically
* loaded libraries
*/
#if defined(_XBOX)
#define EXPORT
#define CALL
#elif defined(_WIN32)
#define EXPORT __declspec(dllexport)
#define CALL __cdecl
#elif (__GNUC__)
#define EXPORT __attribute__((visibility("default")))
#define CALL
#endif
/*
* Optimizing compilers aren't necessarily perfect compilers, but they do
* have that extra chance of supporting explicit [anti-]inline instructions.
*/
#ifdef _MSC_VER
#define INLINE __inline
#define NOINLINE __declspec(noinline)
#define ALIGNED _declspec(align(16))
#elif defined(__GNUC__)
#define INLINE inline
#define NOINLINE __attribute__((noinline))
#define ALIGNED __attribute__((aligned(16)))
#else
#define INLINE
#define NOINLINE
#define ALIGNED
#endif
/*
* aliasing helpers
* Strictly put, this may be unspecified behavior, but it's nice to have!
*/
typedef union {
u8 B[2];
s8 SB[2];
i16 W;
u16 UW;
s16 SW; /* Here, again, explicitly writing "signed" may help clarity. */
} word_16;
typedef union {
u8 B[4];
s8 SB[4];
i16 H[2];
u16 UH[2];
s16 SH[2];
i32 W;
u32 UW;
s32 SW;
} word_32;
typedef union {
u8 B[8];
s8 SB[8];
i16 F[4];
u16 UF[4];
s16 SF[4];
i32 H[2];
u32 UH[2];
s32 SH[2];
i64 W;
u64 UW;
s64 SW;
} word_64;
/*
* helper macros for indexing memory in the above unions
* EEP! Currently concentrates mostly on 32-bit endianness.
*/
#ifndef ENDIAN_M
#if defined(__BIG_ENDIAN__) | (__BYTE_ORDER != __LITTLE_ENDIAN)
#define ENDIAN_M ( 0)
#else
#define ENDIAN_M (~0)
#endif
#endif
#define ENDIAN_SWAP_BYTE (ENDIAN_M & 0x7 & 3)
#define ENDIAN_SWAP_HALF (ENDIAN_M & 0x6 & 2)
#define ENDIAN_SWAP_BIMI (ENDIAN_M & 0x5 & 1)
#define ENDIAN_SWAP_WORD (ENDIAN_M & 0x4 & 0)
#define BES(address) ((address) ^ ENDIAN_SWAP_BYTE)
#define HES(address) ((address) ^ ENDIAN_SWAP_HALF)
#define MES(address) ((address) ^ ENDIAN_SWAP_BIMI)
#define WES(address) ((address) ^ ENDIAN_SWAP_WORD)
/*
* extra types of encoding for the well-known MIPS RISC architecture
* Possibly implement other machine types in future versions of this header.
*/
typedef struct {
unsigned opcode: 6;
unsigned rs: 5;
unsigned rt: 5;
unsigned rd: 5;
unsigned sa: 5;
unsigned function: 6;
} MIPS_type_R;
typedef struct {
unsigned opcode: 6;
unsigned rs: 5;
unsigned rt: 5;
unsigned imm: 16;
} MIPS_type_I;
/*
* Maybe worth including, maybe not.
* It's sketchy since bit-fields pertain to `int' type, of which the size is
* not necessarily going to be even 4 bytes. On C compilers for MIPS itself,
* almost certainly, but is this really important to have?
*/
#if 0
typedef struct {
unsigned opcode: 6;
unsigned target: 26;
} MIPS_type_J;
#endif
/*
* Saying "int" all the time for variables of true/false meaning can be sort
* of misleading. (So can adding dumb features to C99, like "bool".)
*
* Boolean is a proper noun, so the correct name has a capital 'B'.
*/
typedef int Boolean;
#if !defined(FALSE) && !defined(TRUE)
#define FALSE 0
#define TRUE 1
#endif
#endif
| Java |
/*
* Rasengan - Manga and Comic Downloader
* Copyright (C) 2013 Sauriel
*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
package de.sauriel.rasengan.ui;
import java.awt.BorderLayout;
import javax.swing.JDialog;
import javax.swing.JProgressBar;
import javax.swing.JLabel;
import java.util.Observable;
import java.util.Observer;
public class DownloadDialog extends JDialog implements Observer {
private static final long serialVersionUID = 4251447351437107605L;
JProgressBar progressBar;
public DownloadDialog() {
// Configure Dialog
setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
setAlwaysOnTop(true);
setModal(true);
setModalityType(ModalityType.MODELESS);
setResizable(false);
setTitle("Downloading: " + RasenganMainFrame.comic.getName());
setBounds(100, 100, 300, 60);
setLayout(new BorderLayout(0, 0));
// Set Content
JLabel labelDownload = new JLabel("Downloading: " + RasenganMainFrame.comic.getName());
add(labelDownload, BorderLayout.NORTH);
progressBar = new JProgressBar();
add(progressBar, BorderLayout.CENTER);
}
@Override
public void update(Observable comicService, Object imagesCount) {
int[] newImagesCount= (int[]) imagesCount;
progressBar.setMaximum(newImagesCount[1]);
progressBar.setValue(newImagesCount[0]);
if (newImagesCount[0] == newImagesCount[1]) {
dispose();
}
}
}
| Java |
% To rebuild the .pdf from this source, use something like the following
% latex quickref.tex
% dvips -t letter -f -Pcmz < quickref.dvi >| quickref.ps
% ps2pdf -sPAPERSIZE=letter quickref.ps
\documentclass[12pt]{article}
\usepackage[utf-8]{inputenc}
\usepackage{lscape}
\usepackage{setspace}
\usepackage{graphicx}
\usepackage{multicol}
\usepackage[normalem]{ulem}
\usepackage[english]{babel}
\usepackage{color}
\usepackage{hyperref}
\usepackage[T1]{fontenc}
\textheight=9in
\textwidth=7.5in
\headheight=0pt
\headsep=0pt
\topmargin=0in
\oddsidemargin=-0.4in
\evensidemargin=-0.6in
\parindent=0pt
\parsep=1pt
\pagestyle{empty}
\date {}
\makeatother
\begin{document}
\begin{landscape}
% \textit{Dan Kuester's all-leather}
\begin{center}
\begin{minipage}[m]
{1in}\includegraphics[height=0.9in]{../evolution-logo.eps}\hspace{5mm}
\end{minipage}
\hspace{5mm}
\textbf{\Huge{Skedë referimi e shpejtë për Evolution}}
\end{center}
\begin{center}
\begin{multicols}{2}
\section*{Globale}
\begin{tabular*}{4in}{rp{1.5in}}
\textit{\textbf{Përbërës}} & \\
Posta & \textbf{Ctrl+1} \\
Kontakte & \textbf{Ctrl+2} \\
Kalendari & \textbf{Ctrl+3} \\
Aktivitete & \textbf{Ctrl+4} \\
\vspace{1.5mm}
Shënime & \textbf{Ctrl+5} \\
\textit{\textbf{Kontrolle}} & \\
Element i ri në modalitetin aktual & \textbf{Ctrl+N} \\
Shkëmbe fokusin midis panelëve & \textbf{F6} \\
Pastro fushën e kërkimit & \textbf{Shift+Ctrl+Q} \\
Mbyll dritaren & \textbf{Ctrl+W} \\
Hap një dritare të re & \textbf{Shift+Ctrl+W} \\
\vspace{1.5mm}
Mbyll evolution & \textbf{Ctrl+Q} \\
\textit{\textbf{Zgjedhja}} & \\
Printo zgjedhjen & \textbf{Ctrl+P} \\
Ruaj zgjedhjen & \textbf{Ctrl+S} \\
Elemino zgjedhjen & \textbf{Del} ose \textbf{Backspace} \\
Lëviz mesazhe/kontakte tek kartela & \textbf{Shift+Ctrl+V} \\
Kopjo mesazhe/kontakte tek kartela & \textbf{Shift+Ctrl+Y} \\
\end{tabular*}
\section*{Përbërsit e kontakteve/Shënime}
\begin{tabular*}{4in}{rp{1.5in}}
\textit{\textbf{Komandat e përgjithshme}} & \\
Kontakt i ri & \textbf{Shift+Ctrl+C} \\
Listë e re kontaktesh & \textbf{Shift+Ctrl+L} \\
Shënim i ri & \textbf{Shift+Ctrl+O} \\
\end{tabular*}
% {\\ \vspace{5mm} \footnotesize \textit{* denotes the feature may not be implemented yet}}
\section*{Komponenti i postës}
\begin{tabular*}{4in}{rp{1.5in}}
\textit{\textbf{Komandat e përgjithshme}} & \\
Mesazh i ri & \textbf{Shift+Ctrl+M} \\
\vspace{1.5mm}
Dërgo/Merr mesazhe & \textbf{F9} \\
\textit{\textbf{Zgjedhja}} & \\
Apliko filtrat & \textbf{Ctrl+Y} \\
Hap në një dritare të re & \textbf{Return} ose \textbf{Ctrl+O} \\
\vspace{1.5mm}
Përcill zgjedhjen & \textbf{Ctrl+F} \\
\textit{\textbf{Paneli i listës së mesazheve}} & \\
Mesazhi në vijim i palexuar & \textbf{.} ose \textbf{]} \\
\vspace{1.5mm}
Mesazhi paraardhës i palexuar & \textbf{,} ose \textbf{[} \\
\textit{\textbf{Paneli i pamjes së parë}} & \\
Përgjigju dërguesit & \textbf{Ctrl+R} \\
Përgjigju në listë & \textbf{Ctrl+L} \\
Përgjigju të gjithë dërguesve & \textbf{Shift+Ctrl+R} \\
Rrotullo për sipër & \textbf{Backspace} \\
Rrotullo për poshtë & \textbf{Space} \\
\end{tabular*}
\section*{Përbërsit Kalendari/Aktivitete}
\begin{tabular*}{4in}{rp{1.5in}}
\textit{\textbf{Komandat e përgjithshme}} & \\
Takim i ri & \textbf{Shift+Ctrl+A} \\
Mbledhje e re & \textbf{Shift+Ctrl+E} \\
\vspace{1.5mm}
Aktivitet i ri & \textbf{Shift+Ctrl+T} \\
% \vspace{1.5mm}
% Expunge/Purge old schedules & \textbf{Ctrl+E} \\
\textit{\textbf{Lundrimi}} & \\
Shko tek dita e sotme & \textbf{Ctrl+T} \\
Shko tek data & \textbf{Ctrl+G} \\
\end{tabular*}
\end{multicols}
\end{center}
\end{landscape}
\end{document}
| Java |
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager Connection editor -- Connection editor for NetworkManager
*
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Copyright 2012 Red Hat, Inc.
*/
#ifndef __PAGE_MASTER_H__
#define __PAGE_MASTER_H__
#include <nm-connection.h>
#include <glib.h>
#include <glib-object.h>
#include "ce-page.h"
#include "connection-helpers.h"
#define CE_TYPE_PAGE_MASTER (ce_page_master_get_type ())
#define CE_PAGE_MASTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CE_TYPE_PAGE_MASTER, CEPageMaster))
#define CE_PAGE_MASTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CE_TYPE_PAGE_MASTER, CEPageMasterClass))
#define CE_IS_PAGE_MASTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CE_TYPE_PAGE_MASTER))
#define CE_IS_PAGE_MASTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CE_TYPE_PAGE_MASTER))
#define CE_PAGE_MASTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CE_TYPE_PAGE_MASTER, CEPageMasterClass))
typedef struct {
CEPage parent;
gboolean aggregating;
} CEPageMaster;
typedef struct {
CEPageClass parent;
/* signals */
void (*create_connection) (CEPageMaster *self, NMConnection *connection);
void (*connection_added) (CEPageMaster *self, NMConnection *connection);
void (*connection_removed) (CEPageMaster *self, NMConnection *connection);
/* methods */
void (*add_slave) (CEPageMaster *self, NewConnectionResultFunc result_func);
} CEPageMasterClass;
GType ce_page_master_get_type (void);
gboolean ce_page_master_has_slaves (CEPageMaster *self);
#endif /* __PAGE_MASTER_H__ */
| Java |
/**
* App Control
*
* Central controller attached to the top level <html>
* element
*/
"use strict";
( function ( angular, app ) {
// get user profile data
app.controller( "AppCtrl", [ '$rootScope', '$scope', '$state', 'UserService',
function ( $rootScope, $scope, $state, UserService ) {
//
// bodyClass definitions
//
// in a larger project this would be abstracted to allow for multiple
// classes to easily be added or removed
//
// current state
$rootScope.$on( '$stateChangeStart',
function ( event, toState, toParams, fromState, fromParams ) {
var currentState = toState.name.replace( '.', '-' );
$scope.bodyClass = 'state-' + currentState;
}
);
/**
* Format Avatar
*/
$scope.currentUserAvatar = function ( src, size ) {
return UserService.getCurrentUserAvatar( size );
};
}
] );
} )( angular, SimplySocial ); | Java |
package org.openzal.zal.ldap;
import javax.annotation.Nonnull;
public class LdapServerType
{
@Nonnull
private final com.zimbra.cs.ldap.LdapServerType mLdapServerType;
public final static LdapServerType MASTER = new LdapServerType(com.zimbra.cs.ldap.LdapServerType.MASTER);
public final static LdapServerType REPLICA = new LdapServerType(com.zimbra.cs.ldap.LdapServerType.REPLICA);
public LdapServerType(@Nonnull Object ldapServerType)
{
mLdapServerType = (com.zimbra.cs.ldap.LdapServerType)ldapServerType;
}
protected <T> T toZimbra(Class<T> cls)
{
return cls.cast(mLdapServerType);
}
public boolean isMaster() {
return mLdapServerType.isMaster();
}
}
| Java |
package Opsview::Schema::Useragents;
use strict;
use warnings;
use base 'Opsview::DBIx::Class';
__PACKAGE__->load_components(qw/InflateColumn::DateTime Core/);
__PACKAGE__->table( __PACKAGE__->opsviewdb . ".useragents" );
__PACKAGE__->add_columns(
"id",
{
data_type => "VARCHAR",
default_value => undef,
is_nullable => 0,
size => 255
},
"last_update",
{
data_type => "DATETIME",
timezone => "UTC",
default_value => undef,
is_nullable => 0
}
);
__PACKAGE__->set_primary_key( "id" );
# Created by DBIx::Class::Schema::Loader v0.04005 @ 2008-09-17 13:24:37
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:24E+L+rBEoeFJ5x/7Y4nUQ
#
# AUTHORS:
# Copyright (C) 2003-2013 Opsview Limited. All rights reserved
#
# This file is part of Opsview
#
# Opsview 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.
#
# Opsview 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 Opsview; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
# You can replace this text with custom content, and it will be preserved on regeneration
1;
| Java |
'use strict';
/**
* @ngdoc function
* @name quickNewsApp.controller:CbcCtrl
* @description
* # CbcCtrl
* Controller of the quickNewsApp
*/
angular.module('quickNewsApp')
.controller('CbcCtrl', function ($scope, $http) {
this.awesomeThings = [
'HTML5 Boilerplate',
'AngularJS',
'Karma'
];
$scope.postLimit = 10;
$scope.showMorePosts = function() {
$scope.postLimit += 5;
};
$scope.isSet = function(checkTab) {
return this.tab === checkTab;
};
$scope.setTab = function(activeTab) {
this.tab = activeTab;
$scope.postLimit = 10;
$scope.getFeed(activeTab);
};
$scope.getActiveTab = function() {
return this.tab;
};
$scope.getFeed = function(category) {
/*jshint unused: false */
$scope.loading = true;
var url = '//quicknews.amanuppal.ca:5000/cbc?url=' + category;
$http.get(url)
.success(function(data, status, headers, config) {
$scope.entries = data.items;
console.log($scope.entries);
$scope.numEntries = Object.keys($scope.entries).length;
$scope.loading = false;
})
.error(function(data, status, headers, config) {
console.log('Error loading feed: ' + url + ', status: ' + status);
});
};
});
| Java |
package org.hectordam.proyectohector;
import java.util.ArrayList;
import org.hectordam.proyectohector.R;
import org.hectordam.proyectohector.base.Bar;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
import com.google.android.gms.common.GooglePlayServicesClient.ConnectionCallbacks;
import com.google.android.gms.common.GooglePlayServicesClient.OnConnectionFailedListener;
import com.google.android.gms.location.LocationClient;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.CameraUpdate;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.MapsInitializer;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;
import android.location.Location;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import android.view.Menu;
public class Mapa extends FragmentActivity implements LocationListener,ConnectionCallbacks, OnConnectionFailedListener{
private GoogleMap mapa;
private LocationClient locationClient;
private CameraUpdate camara;
private static final LocationRequest LOC_REQUEST = LocationRequest.create()
.setInterval(5000)
.setFastestInterval(16)
.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.mapa);
try {
MapsInitializer.initialize(this);
} catch (GooglePlayServicesNotAvailableException e) {
e.printStackTrace();
}
mapa = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)).getMap();
ArrayList<Bar> bares = getIntent().getParcelableArrayListExtra("bares");
if (bares != null) {
//marcarBares(bares);
}
mapa.setMyLocationEnabled(true);
configuraLocalizador();
camara = CameraUpdateFactory.newLatLng(new LatLng(41.6561, -0.8773));
mapa.moveCamera(camara);
mapa.animateCamera(CameraUpdateFactory.zoomTo(11.0f), 2000, null);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.mapa, menu);
return true;
}
/**
* Añade las marcas de todas las gasolineras
* @param gasolineras
*/
private void marcarBares(ArrayList<Bar> bares) {
if (bares.size() > 0) {
for (Bar bar : bares) {
mapa.addMarker(new MarkerOptions()
.position(new LatLng(bar.getLatitud(), bar.getLongitud()))
.title(bar.getNombre()));
}
}
}
/**
* Se muestra la Activity
*/
@Override
protected void onStart() {
super.onStart();
locationClient.connect();
}
@Override
protected void onStop() {
super.onStop();
locationClient.disconnect();
}
private void configuraLocalizador() {
if (locationClient == null) {
locationClient = new LocationClient(this, this, this);
}
}
@Override
public void onConnected(Bundle arg0) {
locationClient.requestLocationUpdates(LOC_REQUEST, this);
}
@Override
public void onConnectionFailed(ConnectionResult arg0) {
}
@Override
public void onDisconnected() {
}
@Override
public void onLocationChanged(Location arg0) {
}
}
| Java |
/*
* mms_ts.c - Touchscreen driver for Melfas MMS-series touch controllers
*
* Copyright (C) 2011 Google Inc.
* Author: Dima Zavin <dima@android.com>
* Simon Wilson <simonwilson@google.com>
*
* ISP reflashing code based on original code from Melfas.
*
* 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.
*
*/
#define DEBUG
/* #define VERBOSE_DEBUG */
/*#define SEC_TSP_DEBUG*/
/* #define SEC_TSP_VERBOSE_DEBUG */
/* #define FORCE_FW_FLASH */
/* #define FORCE_FW_PASS */
/* #define ESD_DEBUG */
#define SEC_TSP_FACTORY_TEST
#define SEC_TSP_FW_UPDATE
#define TSP_BUF_SIZE 1024
#define FAIL -1
#include <linux/delay.h>
#include <linux/earlysuspend.h>
#include <linux/firmware.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <mach/gpio.h>
#include <linux/uaccess.h>
#include <mach/cpufreq.h>
#include <mach/dev.h>
#include <linux/platform_data/mms_ts.h>
#include <asm/unaligned.h>
#define MAX_FINGERS 10
#define MAX_WIDTH 30
#define MAX_PRESSURE 255
#define MAX_ANGLE 90
#define MIN_ANGLE -90
/* Registers */
#define MMS_MODE_CONTROL 0x01
#define MMS_XYRES_HI 0x02
#define MMS_XRES_LO 0x03
#define MMS_YRES_LO 0x04
#define MMS_INPUT_EVENT_PKT_SZ 0x0F
#define MMS_INPUT_EVENT0 0x10
#define FINGER_EVENT_SZ 8
#define MMS_TSP_REVISION 0xF0
#define MMS_HW_REVISION 0xF1
#define MMS_COMPAT_GROUP 0xF2
#define MMS_FW_VERSION 0xF3
enum {
ISP_MODE_FLASH_ERASE = 0x59F3,
ISP_MODE_FLASH_WRITE = 0x62CD,
ISP_MODE_FLASH_READ = 0x6AC9,
};
/* each address addresses 4-byte words */
#define ISP_MAX_FW_SIZE (0x1F00 * 4)
#define ISP_IC_INFO_ADDR 0x1F00
#ifdef SEC_TSP_FW_UPDATE
#define WORD_SIZE 4
#define ISC_PKT_SIZE 1029
#define ISC_PKT_DATA_SIZE 1024
#define ISC_PKT_HEADER_SIZE 3
#define ISC_PKT_NUM 31
#define ISC_ENTER_ISC_CMD 0x5F
#define ISC_ENTER_ISC_DATA 0x01
#define ISC_CMD 0xAE
#define ISC_ENTER_UPDATE_DATA 0x55
#define ISC_ENTER_UPDATE_DATA_LEN 9
#define ISC_DATA_WRITE_SUB_CMD 0xF1
#define ISC_EXIT_ISC_SUB_CMD 0x0F
#define ISC_EXIT_ISC_SUB_CMD2 0xF0
#define ISC_CHECK_STATUS_CMD 0xAF
#define ISC_CONFIRM_CRC 0x03
#define ISC_DEFAULT_CRC 0xFFFF
#endif
#ifdef SEC_TSP_FACTORY_TEST
#define TX_NUM 26
#define RX_NUM 14
#define NODE_NUM 364 /* 26x14 */
/* VSC(Vender Specific Command) */
#define MMS_VSC_CMD 0xB0 /* vendor specific command */
#define MMS_VSC_MODE 0x1A /* mode of vendor */
#define MMS_VSC_CMD_ENTER 0X01
#define MMS_VSC_CMD_CM_DELTA 0X02
#define MMS_VSC_CMD_CM_ABS 0X03
#define MMS_VSC_CMD_EXIT 0X05
#define MMS_VSC_CMD_INTENSITY 0X04
#define MMS_VSC_CMD_RAW 0X06
#define MMS_VSC_CMD_REFER 0X07
#define TSP_CMD_STR_LEN 32
#define TSP_CMD_RESULT_STR_LEN 512
#define TSP_CMD_PARAM_NUM 8
#endif /* SEC_TSP_FACTORY_TEST */
/* Touch booster */
#if defined(CONFIG_EXYNOS4_CPUFREQ) &&\
defined(CONFIG_BUSFREQ_OPP)
#define TOUCH_BOOSTER 1
#define TOUCH_BOOSTER_OFF_TIME 100
#define TOUCH_BOOSTER_CHG_TIME 200
#else
#define TOUCH_BOOSTER 0
#endif
struct device *sec_touchscreen;
static struct device *bus_dev;
int touch_is_pressed = 0;
#define ISC_DL_MODE 1
/* 4.8" OCTA LCD */
#define FW_VERSION_4_8 0xBD
#define MAX_FW_PATH 255
#define TSP_FW_FILENAME "melfas_fw.bin"
#if ISC_DL_MODE /* ISC_DL_MODE start */
/*
* Default configuration of ISC mode
*/
#define DEFAULT_SLAVE_ADDR 0x48
#define SECTION_NUM 4
#define SECTION_NAME_LEN 5
#define PAGE_HEADER 3
#define PAGE_DATA 1024
#define PAGE_TAIL 2
#define PACKET_SIZE (PAGE_HEADER + PAGE_DATA + PAGE_TAIL)
#define TS_WRITE_REGS_LEN 1030
#define TIMEOUT_CNT 10
#define STRING_BUF_LEN 100
/* State Registers */
#define MIP_ADDR_INPUT_INFORMATION 0x01
#define ISC_ADDR_VERSION 0xE1
#define ISC_ADDR_SECTION_PAGE_INFO 0xE5
/* Config Update Commands */
#define ISC_CMD_ENTER_ISC 0x5F
#define ISC_CMD_ENTER_ISC_PARA1 0x01
#define ISC_CMD_UPDATE_MODE 0xAE
#define ISC_SUBCMD_ENTER_UPDATE 0x55
#define ISC_SUBCMD_DATA_WRITE 0XF1
#define ISC_SUBCMD_LEAVE_UPDATE_PARA1 0x0F
#define ISC_SUBCMD_LEAVE_UPDATE_PARA2 0xF0
#define ISC_CMD_CONFIRM_STATUS 0xAF
#define ISC_STATUS_UPDATE_MODE 0x01
#define ISC_STATUS_CRC_CHECK_SUCCESS 0x03
#define ISC_CHAR_2_BCD(num) (((num/10)<<4) + (num%10))
#define ISC_MAX(x, y) (((x) > (y)) ? (x) : (y))
static const char section_name[SECTION_NUM][SECTION_NAME_LEN] = {
"BOOT", "CORE", "PRIV", "PUBL"
};
static const unsigned char crc0_buf[31] = {
0x1D, 0x2C, 0x05, 0x34, 0x95, 0xA4, 0x8D, 0xBC,
0x59, 0x68, 0x41, 0x70, 0xD1, 0xE0, 0xC9, 0xF8,
0x3F, 0x0E, 0x27, 0x16, 0xB7, 0x86, 0xAF, 0x9E,
0x7B, 0x4A, 0x63, 0x52, 0xF3, 0xC2, 0xEB
};
static const unsigned char crc1_buf[31] = {
0x1E, 0x9C, 0xDF, 0x5D, 0x76, 0xF4, 0xB7, 0x35,
0x2A, 0xA8, 0xEB, 0x69, 0x42, 0xC0, 0x83, 0x01,
0x04, 0x86, 0xC5, 0x47, 0x6C, 0xEE, 0xAD, 0x2F,
0x30, 0xB2, 0xF1, 0x73, 0x58, 0xDA, 0x99
};
static tISCFWInfo_t mbin_info[SECTION_NUM];
static tISCFWInfo_t ts_info[SECTION_NUM]; /* read F/W version from IC */
static bool section_update_flag[SECTION_NUM];
const struct firmware *fw_mbin[SECTION_NUM];
static unsigned char g_wr_buf[1024 + 3 + 2];
#endif
enum fw_flash_mode {
ISP_FLASH,
ISC_FLASH,
};
enum {
BUILT_IN = 0,
UMS,
REQ_FW,
};
struct tsp_callbacks {
void (*inform_charger)(struct tsp_callbacks *tsp_cb, bool mode);
};
struct mms_ts_info {
struct i2c_client *client;
struct input_dev *input_dev;
char phys[32];
int max_x;
int max_y;
bool invert_x;
bool invert_y;
const u8 *config_fw_version;
int irq;
int (*power) (bool on);
struct melfas_tsi_platform_data *pdata;
struct early_suspend early_suspend;
/* protects the enabled flag */
struct mutex lock;
bool enabled;
void (*register_cb)(void *);
struct tsp_callbacks callbacks;
bool ta_status;
bool noise_mode;
unsigned char finger_state[MAX_FINGERS];
#if defined(SEC_TSP_FW_UPDATE)
u8 fw_update_state;
#endif
u8 fw_ic_ver;
enum fw_flash_mode fw_flash_mode;
#if TOUCH_BOOSTER
struct delayed_work work_dvfs_off;
struct delayed_work work_dvfs_chg;
bool dvfs_lock_status;
int cpufreq_level;
struct mutex dvfs_lock;
#endif
#if defined(SEC_TSP_FACTORY_TEST)
struct list_head cmd_list_head;
u8 cmd_state;
char cmd[TSP_CMD_STR_LEN];
int cmd_param[TSP_CMD_PARAM_NUM];
char cmd_result[TSP_CMD_RESULT_STR_LEN];
struct mutex cmd_lock;
bool cmd_is_running;
unsigned int reference[NODE_NUM];
unsigned int raw[NODE_NUM]; /* CM_ABS */
unsigned int inspection[NODE_NUM];/* CM_DELTA */
unsigned int intensity[NODE_NUM];
bool ft_flag;
#endif /* SEC_TSP_FACTORY_TEST */
};
struct mms_fw_image {
__le32 hdr_len;
__le32 data_len;
__le32 fw_ver;
__le32 hdr_ver;
u8 data[0];
} __packed;
#ifdef CONFIG_HAS_EARLYSUSPEND
static void mms_ts_early_suspend(struct early_suspend *h);
static void mms_ts_late_resume(struct early_suspend *h);
#endif
#if TOUCH_BOOSTER
static bool dvfs_lock_status = false;
static bool press_status = false;
#endif
#if defined(SEC_TSP_FACTORY_TEST)
#define TSP_CMD(name, func) .cmd_name = name, .cmd_func = func
struct tsp_cmd {
struct list_head list;
const char *cmd_name;
void (*cmd_func)(void *device_data);
};
static void fw_update(void *device_data);
static void get_fw_ver_bin(void *device_data);
static void get_fw_ver_ic(void *device_data);
static void get_config_ver(void *device_data);
static void get_threshold(void *device_data);
static void module_off_master(void *device_data);
static void module_on_master(void *device_data);
static void module_off_slave(void *device_data);
static void module_on_slave(void *device_data);
static void get_chip_vendor(void *device_data);
static void get_chip_name(void *device_data);
static void get_reference(void *device_data);
static void get_cm_abs(void *device_data);
static void get_cm_delta(void *device_data);
static void get_intensity(void *device_data);
static void get_x_num(void *device_data);
static void get_y_num(void *device_data);
static void run_reference_read(void *device_data);
static void run_cm_abs_read(void *device_data);
static void run_cm_delta_read(void *device_data);
static void run_intensity_read(void *device_data);
static void not_support_cmd(void *device_data);
struct tsp_cmd tsp_cmds[] = {
{TSP_CMD("fw_update", fw_update),},
{TSP_CMD("get_fw_ver_bin", get_fw_ver_bin),},
{TSP_CMD("get_fw_ver_ic", get_fw_ver_ic),},
{TSP_CMD("get_config_ver", get_config_ver),},
{TSP_CMD("get_threshold", get_threshold),},
/* {TSP_CMD("module_off_master", module_off_master),},
{TSP_CMD("module_on_master", module_on_master),},
{TSP_CMD("module_off_slave", not_support_cmd),},
{TSP_CMD("module_on_slave", not_support_cmd),}, */
{TSP_CMD("get_chip_vendor", get_chip_vendor),},
{TSP_CMD("get_chip_name", get_chip_name),},
{TSP_CMD("get_x_num", get_x_num),},
{TSP_CMD("get_y_num", get_y_num),},
{TSP_CMD("get_reference", get_reference),},
{TSP_CMD("get_cm_abs", get_cm_abs),},
{TSP_CMD("get_cm_delta", get_cm_delta),},
{TSP_CMD("get_intensity", get_intensity),},
{TSP_CMD("run_reference_read", run_reference_read),},
{TSP_CMD("run_cm_abs_read", run_cm_abs_read),},
{TSP_CMD("run_cm_delta_read", run_cm_delta_read),},
{TSP_CMD("run_intensity_read", run_intensity_read),},
{TSP_CMD("not_support_cmd", not_support_cmd),},
};
#endif
#if TOUCH_BOOSTER
static void change_dvfs_lock(struct work_struct *work)
{
struct mms_ts_info *info = container_of(work,
struct mms_ts_info, work_dvfs_chg.work);
int ret;
mutex_lock(&info->dvfs_lock);
ret = dev_lock(bus_dev, sec_touchscreen, 267160); /* 266 Mhz setting */
if (ret < 0)
pr_err("%s: dev change bud lock failed(%d)\n",\
__func__, __LINE__);
else
pr_info("[TSP] change_dvfs_lock");
mutex_unlock(&info->dvfs_lock);
}
static void set_dvfs_off(struct work_struct *work)
{
struct mms_ts_info *info = container_of(work,
struct mms_ts_info, work_dvfs_off.work);
int ret;
mutex_lock(&info->dvfs_lock);
ret = dev_unlock(bus_dev, sec_touchscreen);
if (ret < 0)
pr_err("%s: dev unlock failed(%d)\n",
__func__, __LINE__);
exynos_cpufreq_lock_free(DVFS_LOCK_ID_TSP);
info->dvfs_lock_status = false;
pr_info("[TSP] DVFS Off!");
mutex_unlock(&info->dvfs_lock);
}
static void set_dvfs_lock(struct mms_ts_info *info, uint32_t on)
{
int ret;
mutex_lock(&info->dvfs_lock);
if (info->cpufreq_level <= 0) {
ret = exynos_cpufreq_get_level(800000, &info->cpufreq_level);
if (ret < 0)
pr_err("[TSP] exynos_cpufreq_get_level error");
goto out;
}
if (on == 0) {
if (info->dvfs_lock_status) {
cancel_delayed_work(&info->work_dvfs_chg);
schedule_delayed_work(&info->work_dvfs_off,
msecs_to_jiffies(TOUCH_BOOSTER_OFF_TIME));
}
} else if (on == 1) {
cancel_delayed_work(&info->work_dvfs_off);
if (!info->dvfs_lock_status) {
ret = dev_lock(bus_dev, sec_touchscreen, 400200);
if (ret < 0) {
pr_err("%s: dev lock failed(%d)\n",\
__func__, __LINE__);
}
ret = exynos_cpufreq_lock(DVFS_LOCK_ID_TSP,
info->cpufreq_level);
if (ret < 0)
pr_err("%s: cpu lock failed(%d)\n",\
__func__, __LINE__);
schedule_delayed_work(&info->work_dvfs_chg,
msecs_to_jiffies(TOUCH_BOOSTER_CHG_TIME));
info->dvfs_lock_status = true;
pr_info("[TSP] DVFS On![%d]", info->cpufreq_level);
}
} else if (on == 2) {
cancel_delayed_work(&info->work_dvfs_off);
cancel_delayed_work(&info->work_dvfs_chg);
schedule_work(&info->work_dvfs_off.work);
}
out:
mutex_unlock(&info->dvfs_lock);
}
#endif
static inline void mms_pwr_on_reset(struct mms_ts_info *info)
{
struct i2c_adapter *adapter = to_i2c_adapter(info->client->dev.parent);
if (!info->pdata->mux_fw_flash) {
dev_info(&info->client->dev,
"missing platform data, can't do power-on-reset\n");
return;
}
i2c_lock_adapter(adapter);
info->pdata->mux_fw_flash(true);
info->pdata->power(false);
gpio_direction_output(info->pdata->gpio_sda, 0);
gpio_direction_output(info->pdata->gpio_scl, 0);
gpio_direction_output(info->pdata->gpio_int, 0);
msleep(50);
info->pdata->power(true);
msleep(200);
info->pdata->mux_fw_flash(false);
i2c_unlock_adapter(adapter);
/* TODO: Seems long enough for the firmware to boot.
* Find the right value */
msleep(250);
}
static void release_all_fingers(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
int i;
pr_debug(KERN_DEBUG "[TSP] %s\n", __func__);
for (i = 0; i < MAX_FINGERS; i++) {
if (info->finger_state[i] == 1) {
dev_notice(&client->dev, "finger %d up(force)\n", i);
}
info->finger_state[i] = 0;
input_mt_slot(info->input_dev, i);
input_mt_report_slot_state(info->input_dev, MT_TOOL_FINGER,
false);
}
input_sync(info->input_dev);
#if TOUCH_BOOSTER
set_dvfs_lock(info, 2);
pr_info("[TSP] dvfs_lock free.\n ");
#endif
}
static void mms_set_noise_mode(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
if (!(info->noise_mode && info->enabled))
return;
dev_notice(&client->dev, "%s\n", __func__);
if (info->ta_status) {
dev_notice(&client->dev, "noise_mode & TA connect!!!\n");
i2c_smbus_write_byte_data(info->client, 0x30, 0x1);
} else {
dev_notice(&client->dev, "noise_mode & TA disconnect!!!\n");
i2c_smbus_write_byte_data(info->client, 0x30, 0x2);
}
}
static void reset_mms_ts(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
if (info->enabled == false)
return;
dev_notice(&client->dev, "%s++\n", __func__);
disable_irq_nosync(info->irq);
info->enabled = false;
touch_is_pressed = 0;
release_all_fingers(info);
mms_pwr_on_reset(info);
enable_irq(info->irq);
info->enabled = true;
if (info->ta_status) {
dev_notice(&client->dev, "TA connect!!!\n");
i2c_smbus_write_byte_data(info->client, 0x33, 0x1);
} else {
dev_notice(&client->dev, "TA disconnect!!!\n");
i2c_smbus_write_byte_data(info->client, 0x33, 0x2);
}
mms_set_noise_mode(info);
dev_notice(&client->dev, "%s--\n", __func__);
}
static void melfas_ta_cb(struct tsp_callbacks *cb, bool ta_status)
{
struct mms_ts_info *info =
container_of(cb, struct mms_ts_info, callbacks);
struct i2c_client *client = info->client;
dev_notice(&client->dev, "%s\n", __func__);
info->ta_status = ta_status;
if (info->enabled) {
if (info->ta_status) {
dev_notice(&client->dev, "TA connect!!!\n");
i2c_smbus_write_byte_data(info->client, 0x33, 0x1);
} else {
dev_notice(&client->dev, "TA disconnect!!!\n");
i2c_smbus_write_byte_data(info->client, 0x33, 0x2);
}
mms_set_noise_mode(info);
}
}
static irqreturn_t mms_ts_interrupt(int irq, void *dev_id)
{
struct mms_ts_info *info = dev_id;
struct i2c_client *client = info->client;
u8 buf[MAX_FINGERS * FINGER_EVENT_SZ] = { 0 };
int ret;
int i;
int sz;
u8 reg = MMS_INPUT_EVENT0;
struct i2c_msg msg[] = {
{
.addr = client->addr,
.flags = 0,
.buf = ®,
.len = 1,
}, {
.addr = client->addr,
.flags = I2C_M_RD,
.buf = buf,
},
};
sz = i2c_smbus_read_byte_data(client, MMS_INPUT_EVENT_PKT_SZ);
if (sz < 0) {
dev_err(&client->dev, "%s bytes=%d\n", __func__, sz);
for (i = 0; i < 50; i++) {
sz = i2c_smbus_read_byte_data(client,
MMS_INPUT_EVENT_PKT_SZ);
if (sz > 0)
break;
}
if (i == 50) {
dev_dbg(&client->dev, "i2c failed... reset!!\n");
reset_mms_ts(info);
goto out;
}
}
/* BUG_ON(sz > MAX_FINGERS*FINGER_EVENT_SZ); */
if (sz == 0)
goto out;
if (sz > MAX_FINGERS*FINGER_EVENT_SZ) {
dev_err(&client->dev, "[TSP] abnormal data inputed.\n");
goto out;
}
msg[1].len = sz;
ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
if (ret != ARRAY_SIZE(msg)) {
dev_err(&client->dev,
"failed to read %d bytes of touch data (%d)\n",
sz, ret);
goto out;
}
#if defined(VERBOSE_DEBUG)
print_hex_dump(KERN_DEBUG, "mms_ts raw: ",
DUMP_PREFIX_OFFSET, 32, 1, buf, sz, false);
#endif
if (buf[0] == 0x0F) { /* ESD */
dev_dbg(&client->dev, "ESD DETECT.... reset!!\n");
reset_mms_ts(info);
goto out;
}
if (buf[0] == 0x0E) { /* NOISE MODE */
dev_dbg(&client->dev, "[TSP] noise mode enter!!\n");
info->noise_mode = 1 ;
mms_set_noise_mode(info);
goto out;
}
for (i = 0; i < sz; i += FINGER_EVENT_SZ) {
u8 *tmp = &buf[i];
int id = (tmp[0] & 0xf) - 1;
int x = tmp[2] | ((tmp[1] & 0xf) << 8);
int y = tmp[3] | (((tmp[1] >> 4) & 0xf) << 8);
int angle = (tmp[5] >= 127) ? (-(256 - tmp[5])) : tmp[5];
int palm = (tmp[0] & 0x10) >> 4;
if (info->invert_x) {
x = info->max_x - x;
if (x < 0)
x = 0;
}
if (info->invert_y) {
y = info->max_y - y;
if (y < 0)
y = 0;
}
if (id >= MAX_FINGERS) {
dev_notice(&client->dev, \
"finger id error [%d]\n", id);
reset_mms_ts(info);
goto out;
}
if ((tmp[0] & 0x80) == 0) {
#if defined(SEC_TSP_DEBUG)
dev_dbg(&client->dev,
"finger id[%d]: x=%d y=%d p=%d w=%d major=%d minor=%d angle=%d palm=%d\n",
id, x, y, tmp[5], tmp[4], tmp[6], tmp[7]
, angle, palm);
#else
if (info->finger_state[id] != 0) {
dev_notice(&client->dev,
"finger [%d] up, palm %d\n", id, palm);
}
#endif
input_mt_slot(info->input_dev, id);
input_mt_report_slot_state(info->input_dev,
MT_TOOL_FINGER, false);
info->finger_state[id] = 0;
continue;
}
input_mt_slot(info->input_dev, id);
input_mt_report_slot_state(info->input_dev,
MT_TOOL_FINGER, true);
input_report_abs(info->input_dev, ABS_MT_WIDTH_MAJOR, tmp[4]);
input_report_abs(info->input_dev, ABS_MT_POSITION_X, x);
input_report_abs(info->input_dev, ABS_MT_POSITION_Y, y);
input_report_abs(info->input_dev, ABS_MT_TOUCH_MAJOR, tmp[6]);
input_report_abs(info->input_dev, ABS_MT_TOUCH_MINOR, tmp[7]);
input_report_abs(info->input_dev, ABS_MT_ANGLE, angle);
input_report_abs(info->input_dev, ABS_MT_PALM, palm);
#if defined(SEC_TSP_DEBUG)
if (info->finger_state[id] == 0) {
info->finger_state[id] = 1;
dev_dbg(&client->dev,
"finger id[%d]: x=%d y=%d w=%d major=%d minor=%d angle=%d palm=%d\n",
id, x, y, tmp[4], tmp[6], tmp[7]
, angle, palm);
if (finger_event_sz == 10)
dev_dbg(&client->dev, \
"pressure = %d\n", tmp[8]);
}
#else
if (info->finger_state[id] == 0) {
info->finger_state[id] = 1;
dev_notice(&client->dev,
"finger [%d] down, palm %d\n", id, palm);
}
#endif
}
input_sync(info->input_dev);
touch_is_pressed = 0;
for (i = 0; i < MAX_FINGERS; i++) {
if (info->finger_state[i] == 1)
touch_is_pressed++;
}
#if TOUCH_BOOSTER
set_dvfs_lock(info, !!touch_is_pressed);
#endif
out:
return IRQ_HANDLED;
}
int get_tsp_status(void)
{
return touch_is_pressed;
}
EXPORT_SYMBOL(get_tsp_status);
#if ISC_DL_MODE
static int mms100_i2c_read(struct i2c_client *client,
u16 addr, u16 length, u8 *value)
{
struct i2c_adapter *adapter = client->adapter;
struct i2c_msg msg;
int ret = -1;
msg.addr = client->addr;
msg.flags = 0x00;
msg.len = 1;
msg.buf = (u8 *) &addr;
ret = i2c_transfer(adapter, &msg, 1);
if (ret >= 0) {
msg.addr = client->addr;
msg.flags = I2C_M_RD;
msg.len = length;
msg.buf = (u8 *) value;
ret = i2c_transfer(adapter, &msg, 1);
}
if (ret < 0)
pr_err("[TSP] : read error : [%d]", ret);
return ret;
}
static int mms100_reset(struct mms_ts_info *info)
{
info->pdata->power(false);
msleep(30);
info->pdata->power(true);
msleep(300);
return ISC_SUCCESS;
}
/*
static int mms100_check_operating_mode(struct i2c_client *_client,
const int _error_code)
{
int ret;
unsigned char rd_buf = 0x00;
unsigned char count = 0;
if(_client == NULL)
pr_err("[TSP ISC] _client is null");
ret = mms100_i2c_read(_client, ISC_ADDR_VERSION, 1, &rd_buf);
if (ret<0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return _error_code;
}
return ISC_SUCCESS;
}
*/
static int mms100_get_version_info(struct i2c_client *_client)
{
int i, ret;
unsigned char rd_buf[8];
/* config version brust read (core, private, public) */
ret = mms100_i2c_read(_client, ISC_ADDR_VERSION, 4, rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
for (i = 0; i < SECTION_NUM; i++)
ts_info[i].version = rd_buf[i];
ts_info[SEC_CORE].compatible_version =
ts_info[SEC_BOOTLOADER].version;
ts_info[SEC_PRIVATE_CONFIG].compatible_version =
ts_info[SEC_PUBLIC_CONFIG].compatible_version =
ts_info[SEC_CORE].version;
ret = mms100_i2c_read(_client, ISC_ADDR_SECTION_PAGE_INFO, 8, rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
for (i = 0; i < SECTION_NUM; i++) {
ts_info[i].start_addr = rd_buf[i];
ts_info[i].end_addr = rd_buf[i + SECTION_NUM];
}
for (i = 0; i < SECTION_NUM; i++) {
pr_info("TS : Section(%d) version: 0x%02X\n",
i, ts_info[i].version);
pr_info("TS : Section(%d) Start Address: 0x%02X\n",
i, ts_info[i].start_addr);
pr_info("TS : Section(%d) End Address: 0x%02X\n",
i, ts_info[i].end_addr);
pr_info("TS : Section(%d) Compatibility: 0x%02X\n",
i, ts_info[i].compatible_version);
}
return ISC_SUCCESS;
}
static int mms100_seek_section_info(void)
{
int i;
char str_buf[STRING_BUF_LEN];
char name_buf[SECTION_NAME_LEN];
int version;
int page_num;
const unsigned char *buf;
int next_ptr;
for (i = 0; i < SECTION_NUM; i++) {
if (fw_mbin[i] == NULL) {
buf = NULL;
pr_info("[TSP ISC] fw_mbin[%d]->data is NULL", i);
} else {
buf = fw_mbin[i]->data;
}
if (buf == NULL) {
mbin_info[i].version = ts_info[i].version;
mbin_info[i].compatible_version =
ts_info[i].compatible_version;
mbin_info[i].start_addr = ts_info[i].start_addr;
mbin_info[i].end_addr = ts_info[i].end_addr;
} else {
next_ptr = 0;
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "SECTION_NAME"));
sscanf(buf + next_ptr, "%s%s", str_buf, name_buf);
if (strncmp(section_name[i], name_buf,
SECTION_NAME_LEN))
return ISC_FILE_FORMAT_ERROR;
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "SECTION_VERSION"));
sscanf(buf + next_ptr, "%s%d", str_buf, &version);
mbin_info[i].version = ISC_CHAR_2_BCD(version);
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "START_PAGE_ADDR"));
sscanf(buf + next_ptr, "%s%d", str_buf, &page_num);
mbin_info[i].start_addr = page_num;
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "END_PAGE_ADDR"));
sscanf(buf + next_ptr, "%s%d", str_buf, &page_num);
mbin_info[i].end_addr = page_num;
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "COMPATIBLE_VERSION"));
sscanf(buf + next_ptr, "%s%d", str_buf, &version);
mbin_info[i].compatible_version =
ISC_CHAR_2_BCD(version);
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "[Binary]"));
if (mbin_info[i].version == 0xFF)
return ISC_FILE_FORMAT_ERROR;
}
}
for (i = 0; i < SECTION_NUM; i++) {
pr_info("[TSP ISC] MBin : Section(%d) Version: 0x%02X\n",
i, mbin_info[i].version);
pr_info("[TSP ISC] MBin : Section(%d) Start Address: 0x%02X\n",
i, mbin_info[i].start_addr);
pr_info("[TSP ISC] MBin : Section(%d) End Address: 0x%02X\n",
i, mbin_info[i].end_addr);
pr_info("[TSP ISC] MBin : Section(%d) Compatibility: 0x%02X\n",
i, mbin_info[i].compatible_version);
}
return ISC_SUCCESS;
}
static eISCRet_t mms100_compare_version_info(struct i2c_client *_client)
{
int i, ret;
unsigned char expected_compatibility[SECTION_NUM];
if (mms100_get_version_info(_client) != ISC_SUCCESS)
return ISC_I2C_ERROR;
ret = mms100_seek_section_info();
/* Check update areas , 0 : bootloader 1: core 2: private 3: public */
for (i = 0; i < SECTION_NUM; i++) {
if ((mbin_info[i].version == 0) ||
(mbin_info[i].version != ts_info[i].version)) {
section_update_flag[i] = true;
pr_info("[TSP ISC] [%d] section will be updated!", i);
}
}
section_update_flag[0] = false;
pr_info("[TSP ISC] [%d] [%d] [%d]", section_update_flag[1],
section_update_flag[2], section_update_flag[3]);
if (section_update_flag[SEC_BOOTLOADER]) {
expected_compatibility[SEC_CORE] =
mbin_info[SEC_BOOTLOADER].version;
} else {
expected_compatibility[SEC_CORE] =
ts_info[SEC_BOOTLOADER].version;
}
if (section_update_flag[SEC_CORE]) {
expected_compatibility[SEC_PUBLIC_CONFIG] =
expected_compatibility[SEC_PRIVATE_CONFIG] =
mbin_info[SEC_CORE].version;
} else {
expected_compatibility[SEC_PUBLIC_CONFIG] =
expected_compatibility[SEC_PRIVATE_CONFIG] =
ts_info[SEC_CORE].version;
}
for (i = SEC_CORE; i < SEC_PUBLIC_CONFIG; i++) {
if (section_update_flag[i]) {
pr_info("[TSP ISC] section_update_flag(%d), 0x%02x, 0x%02x\n",
i, expected_compatibility[i],
mbin_info[i].compatible_version);
if (expected_compatibility[i] !=
mbin_info[i].compatible_version)
return ISC_COMPATIVILITY_ERROR;
} else {
pr_info("[TSP ISC] !section_update_flag(%d), 0x%02x, 0x%02x\n",
i, expected_compatibility[i],
ts_info[i].compatible_version);
if (expected_compatibility[i] !=
ts_info[i].compatible_version)
return ISC_COMPATIVILITY_ERROR;
}
}
return ISC_SUCCESS;
}
static int mms100_enter_ISC_mode(struct i2c_client *_client)
{
int ret;
unsigned char wr_buf[2];
pr_info("[TSP ISC] %s\n", __func__);
wr_buf[0] = ISC_CMD_ENTER_ISC;
wr_buf[1] = ISC_CMD_ENTER_ISC_PARA1;
ret = i2c_master_send(_client, wr_buf, 2);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c write fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
msleep(50);
return ISC_SUCCESS;
}
static int mms100_enter_config_update(struct i2c_client *_client)
{
int ret;
unsigned char wr_buf[10] = {0,};
unsigned char rd_buf;
wr_buf[0] = ISC_CMD_UPDATE_MODE;
wr_buf[1] = ISC_SUBCMD_ENTER_UPDATE;
ret = i2c_master_send(_client, wr_buf, 10);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c write fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
ret = mms100_i2c_read(_client, ISC_CMD_CONFIRM_STATUS, 1, &rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
if (rd_buf != ISC_STATUS_UPDATE_MODE)
return ISC_UPDATE_MODE_ENTER_ERROR;
pr_info("[TSP ISC]End mms100_enter_config_update()\n");
return ISC_SUCCESS;
}
static int mms100_ISC_clear_page(struct i2c_client *_client,
unsigned char _page_addr)
{
int ret;
unsigned char rd_buf;
memset(&g_wr_buf[3], 0xFF, PAGE_DATA);
g_wr_buf[0] = ISC_CMD_UPDATE_MODE; /* command */
g_wr_buf[1] = ISC_SUBCMD_DATA_WRITE; /* sub_command */
g_wr_buf[2] = _page_addr;
g_wr_buf[PAGE_HEADER + PAGE_DATA] = crc0_buf[_page_addr];
g_wr_buf[PAGE_HEADER + PAGE_DATA + 1] = crc1_buf[_page_addr];
ret = i2c_master_send(_client, g_wr_buf, PACKET_SIZE);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c write fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
ret = mms100_i2c_read(_client, ISC_CMD_CONFIRM_STATUS, 1, &rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
if (rd_buf != ISC_STATUS_CRC_CHECK_SUCCESS)
return ISC_UPDATE_MODE_ENTER_ERROR;
pr_info("[TSP ISC]End mms100_ISC_clear_page()\n");
return ISC_SUCCESS;
}
static int mms100_ISC_clear_validate_markers(struct i2c_client *_client)
{
int ret_msg;
int i, j;
bool is_matched_address;
for (i = SEC_CORE; i <= SEC_PUBLIC_CONFIG; i++) {
if (section_update_flag[i]) {
if (ts_info[i].end_addr <= 30 &&
ts_info[i].end_addr > 0) {
ret_msg = mms100_ISC_clear_page(_client,
ts_info[i].end_addr);
if (ret_msg != ISC_SUCCESS)
return ret_msg;
}
}
}
for (i = SEC_CORE; i <= SEC_PUBLIC_CONFIG; i++) {
if (section_update_flag[i]) {
is_matched_address = false;
for (j = SEC_CORE; j <= SEC_PUBLIC_CONFIG; j++) {
if (mbin_info[i].end_addr ==
ts_info[i].end_addr) {
is_matched_address = true;
break;
}
}
if (!is_matched_address) {
if (mbin_info[i].end_addr <= 30 &&
mbin_info[i].end_addr > 0) {
ret_msg = mms100_ISC_clear_page(_client,
mbin_info[i].end_addr);
if (ret_msg != ISC_SUCCESS)
return ret_msg;
}
}
}
}
return ISC_SUCCESS;
}
static int mms100_update_section_data(struct i2c_client *_client)
{
int i, ret, next_ptr;
unsigned char rd_buf;
const unsigned char *ptr_fw;
char str_buf[STRING_BUF_LEN];
int page_addr;
for (i = 0; i < SECTION_NUM; i++) {
if (section_update_flag[i]) {
pr_info("[TSP ISC] section data i2c flash : [%d]", i);
next_ptr = 0;
ptr_fw = fw_mbin[i]->data;
do {
sscanf(ptr_fw + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "[Binary]"));
ptr_fw = ptr_fw + next_ptr + 2;
for (page_addr = mbin_info[i].start_addr;
page_addr <= mbin_info[i].end_addr;
page_addr++) {
if (page_addr - mbin_info[i].start_addr > 0)
ptr_fw += PACKET_SIZE;
if ((ptr_fw[0] != ISC_CMD_UPDATE_MODE) ||
(ptr_fw[1] != ISC_SUBCMD_DATA_WRITE) ||
(ptr_fw[2] != page_addr))
return ISC_WRITE_BUFFER_ERROR;
ret = i2c_master_send(_client,
ptr_fw, PACKET_SIZE);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c write fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
ret = mms100_i2c_read(_client,
ISC_CMD_CONFIRM_STATUS, 1, &rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
if (rd_buf != ISC_STATUS_CRC_CHECK_SUCCESS)
return ISC_CRC_ERROR;
section_update_flag[i] = false;
}
}
}
pr_info("[TSP ISC]End mms100_update_section_data()\n");
return ISC_SUCCESS;
}
static eISCRet_t mms100_open_mbinary(struct i2c_client *_client)
{
int i;
char file_name[64];
int ret = 0;
ret += request_firmware(&(fw_mbin[1]),\
"tsp_melfas/CORE.fw", &_client->dev);
ret += request_firmware(&(fw_mbin[2]),\
"tsp_melfas/PRIV.fw", &_client->dev);
ret += request_firmware(&(fw_mbin[3]),\
"tsp_melfas/PUBL.fw", &_client->dev);
if (!ret)
return ISC_SUCCESS;
else {
pr_info("[TSP ISC] request_firmware fail");
return ret;
}
}
static eISCRet_t mms100_close_mbinary(void)
{
int i;
for (i = 0; i < SECTION_NUM; i++) {
if (fw_mbin[i] != NULL)
release_firmware(fw_mbin[i]);
}
return ISC_SUCCESS;
}
eISCRet_t mms100_ISC_download_mbinary(struct mms_ts_info *info)
{
struct i2c_client *_client = info->client;
eISCRet_t ret_msg = ISC_NONE;
pr_info("[TSP ISC] %s\n", __func__);
mms100_reset(info);
/* ret_msg = mms100_check_operating_mode(_client, EC_BOOT_ON_SUCCEEDED);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
*/
ret_msg = mms100_open_mbinary(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
/*Config version Check*/
ret_msg = mms100_compare_version_info(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
ret_msg = mms100_enter_ISC_mode(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
ret_msg = mms100_enter_config_update(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
ret_msg = mms100_ISC_clear_validate_markers(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
pr_info("[TSP ISC]mms100_update_section_data start");
ret_msg = mms100_update_section_data(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
pr_info("[TSP ISC]mms100_update_section_data end");
/* mms100_reset(info); */
pr_info("[TSP ISC]FIRMWARE_UPDATE_FINISHED!!!\n");
ret_msg = ISC_SUCCESS;
ISC_ERROR_HANDLE:
if (ret_msg != ISC_SUCCESS)
pr_info("[TSP ISC]ISC_ERROR_CODE: %d\n", ret_msg);
mms100_reset(info);
mms100_close_mbinary();
return ret_msg;
}
#endif /* ISC_DL_MODE start */
static void hw_reboot(struct mms_ts_info *info, bool bootloader)
{
info->pdata->power(false);
gpio_direction_output(info->pdata->gpio_sda, bootloader ? 0 : 1);
gpio_direction_output(info->pdata->gpio_scl, bootloader ? 0 : 1);
gpio_direction_output(info->pdata->gpio_int, 0);
msleep(30);
info->pdata->power(true);
msleep(30);
if (bootloader) {
gpio_set_value(info->pdata->gpio_scl, 0);
gpio_set_value(info->pdata->gpio_sda, 1);
} else {
gpio_set_value(info->pdata->gpio_int, 1);
gpio_direction_input(info->pdata->gpio_int);
gpio_direction_input(info->pdata->gpio_scl);
gpio_direction_input(info->pdata->gpio_sda);
}
msleep(40);
}
static inline void hw_reboot_bootloader(struct mms_ts_info *info)
{
hw_reboot(info, true);
}
static inline void hw_reboot_normal(struct mms_ts_info *info)
{
hw_reboot(info, false);
}
static void isp_toggle_clk(struct mms_ts_info *info, int start_lvl, int end_lvl,
int hold_us)
{
gpio_set_value(info->pdata->gpio_scl, start_lvl);
udelay(hold_us);
gpio_set_value(info->pdata->gpio_scl, end_lvl);
udelay(hold_us);
}
/* 1 <= cnt <= 32 bits to write */
static void isp_send_bits(struct mms_ts_info *info, u32 data, int cnt)
{
gpio_direction_output(info->pdata->gpio_int, 0);
gpio_direction_output(info->pdata->gpio_scl, 0);
gpio_direction_output(info->pdata->gpio_sda, 0);
/* clock out the bits, msb first */
while (cnt--) {
gpio_set_value(info->pdata->gpio_sda, (data >> cnt) & 1);
udelay(3);
isp_toggle_clk(info, 1, 0, 3);
}
}
/* 1 <= cnt <= 32 bits to read */
static u32 isp_recv_bits(struct mms_ts_info *info, int cnt)
{
u32 data = 0;
gpio_direction_output(info->pdata->gpio_int, 0);
gpio_direction_output(info->pdata->gpio_scl, 0);
gpio_set_value(info->pdata->gpio_sda, 0);
gpio_direction_input(info->pdata->gpio_sda);
/* clock in the bits, msb first */
while (cnt--) {
isp_toggle_clk(info, 0, 1, 1);
data = (data << 1) | (!!gpio_get_value(info->pdata->gpio_sda));
}
gpio_direction_output(info->pdata->gpio_sda, 0);
return data;
}
static void isp_enter_mode(struct mms_ts_info *info, u32 mode)
{
int cnt;
unsigned long flags;
local_irq_save(flags);
gpio_direction_output(info->pdata->gpio_int, 0);
gpio_direction_output(info->pdata->gpio_scl, 0);
gpio_direction_output(info->pdata->gpio_sda, 1);
mode &= 0xffff;
for (cnt = 15; cnt >= 0; cnt--) {
gpio_set_value(info->pdata->gpio_int, (mode >> cnt) & 1);
udelay(3);
isp_toggle_clk(info, 1, 0, 3);
}
gpio_set_value(info->pdata->gpio_int, 0);
local_irq_restore(flags);
}
static void isp_exit_mode(struct mms_ts_info *info)
{
int i;
unsigned long flags;
local_irq_save(flags);
gpio_direction_output(info->pdata->gpio_int, 0);
udelay(3);
for (i = 0; i < 10; i++)
isp_toggle_clk(info, 1, 0, 3);
local_irq_restore(flags);
}
static void flash_set_address(struct mms_ts_info *info, u16 addr)
{
/* Only 13 bits of addr are valid.
* The addr is in bits 13:1 of cmd */
isp_send_bits(info, (u32) (addr & 0x1fff) << 1, 18);
}
static void flash_erase(struct mms_ts_info *info)
{
isp_enter_mode(info, ISP_MODE_FLASH_ERASE);
gpio_direction_output(info->pdata->gpio_int, 0);
gpio_direction_output(info->pdata->gpio_scl, 0);
gpio_direction_output(info->pdata->gpio_sda, 1);
/* 4 clock cycles with different timings for the erase to
* get processed, clk is already 0 from above */
udelay(7);
isp_toggle_clk(info, 1, 0, 3);
udelay(7);
isp_toggle_clk(info, 1, 0, 3);
usleep_range(25000, 35000);
isp_toggle_clk(info, 1, 0, 3);
usleep_range(150, 200);
isp_toggle_clk(info, 1, 0, 3);
gpio_set_value(info->pdata->gpio_sda, 0);
isp_exit_mode(info);
}
static u32 flash_readl(struct mms_ts_info *info, u16 addr)
{
int i;
u32 val;
unsigned long flags;
local_irq_save(flags);
isp_enter_mode(info, ISP_MODE_FLASH_READ);
flash_set_address(info, addr);
gpio_direction_output(info->pdata->gpio_scl, 0);
gpio_direction_output(info->pdata->gpio_sda, 0);
udelay(40);
/* data load cycle */
for (i = 0; i < 6; i++)
isp_toggle_clk(info, 1, 0, 10);
val = isp_recv_bits(info, 32);
isp_exit_mode(info);
local_irq_restore(flags);
return val;
}
static void flash_writel(struct mms_ts_info *info, u16 addr, u32 val)
{
unsigned long flags;
local_irq_save(flags);
isp_enter_mode(info, ISP_MODE_FLASH_WRITE);
flash_set_address(info, addr);
isp_send_bits(info, val, 32);
gpio_direction_output(info->pdata->gpio_sda, 1);
/* 6 clock cycles with different timings for the data to get written
* into flash */
isp_toggle_clk(info, 0, 1, 3);
isp_toggle_clk(info, 0, 1, 3);
isp_toggle_clk(info, 0, 1, 6);
isp_toggle_clk(info, 0, 1, 12);
isp_toggle_clk(info, 0, 1, 3);
isp_toggle_clk(info, 0, 1, 3);
isp_toggle_clk(info, 1, 0, 1);
gpio_direction_output(info->pdata->gpio_sda, 0);
isp_exit_mode(info);
local_irq_restore(flags);
usleep_range(300, 400);
}
static bool flash_is_erased(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
u32 val;
u16 addr;
for (addr = 0; addr < (ISP_MAX_FW_SIZE / 4); addr++) {
udelay(40);
val = flash_readl(info, addr);
if (val != 0xffffffff) {
dev_dbg(&client->dev,
"addr 0x%x not erased: 0x%08x != 0xffffffff\n",
addr, val);
return false;
}
}
return true;
}
static int fw_write_image(struct mms_ts_info *info, const u8 * data, size_t len)
{
struct i2c_client *client = info->client;
u16 addr = 0;
for (addr = 0; addr < (len / 4); addr++, data += 4) {
u32 val = get_unaligned_le32(data);
u32 verify_val;
int retries = 3;
while (retries--) {
flash_writel(info, addr, val);
verify_val = flash_readl(info, addr);
if (val == verify_val)
break;
dev_err(&client->dev,
"mismatch @ addr 0x%x: 0x%x != 0x%x\n",
addr, verify_val, val);
continue;
}
if (retries < 0)
return -ENXIO;
}
return 0;
}
static int fw_download(struct mms_ts_info *info, const u8 * data, size_t len)
{
struct i2c_client *client = info->client;
u32 val;
int ret = 0;
if (len % 4) {
dev_err(&client->dev,
"fw image size (%d) must be a multiple of 4 bytes\n",
len);
return -EINVAL;
} else if (len > ISP_MAX_FW_SIZE) {
dev_err(&client->dev,
"fw image is too big, %d > %d\n", len, ISP_MAX_FW_SIZE);
return -EINVAL;
}
dev_info(&client->dev, "fw download start\n");
info->pdata->power(false);
gpio_direction_output(info->pdata->gpio_sda, 0);
gpio_direction_output(info->pdata->gpio_scl, 0);
gpio_direction_output(info->pdata->gpio_int, 0);
hw_reboot_bootloader(info);
val = flash_readl(info, ISP_IC_INFO_ADDR);
dev_info(&client->dev, "IC info: 0x%02x (%x)\n", val & 0xff, val);
dev_info(&client->dev, "fw erase...\n");
flash_erase(info);
if (!flash_is_erased(info)) {
ret = -ENXIO;
goto err;
}
dev_info(&client->dev, "fw write...\n");
/* XXX: what does this do?! */
flash_writel(info, ISP_IC_INFO_ADDR, 0xffffff00 | (val & 0xff));
usleep_range(1000, 1500);
ret = fw_write_image(info, data, len);
if (ret)
goto err;
usleep_range(1000, 1500);
hw_reboot_normal(info);
usleep_range(1000, 1500);
dev_info(&client->dev, "fw download done...\n");
return 0;
err:
dev_err(&client->dev, "fw download failed...\n");
hw_reboot_normal(info);
return ret;
}
#if defined(SEC_TSP_ISC_FW_UPDATE)
static u16 gen_crc(u8 data, u16 pre_crc)
{
u16 crc;
u16 cur;
u16 temp;
u16 bit_1;
u16 bit_2;
int i;
crc = pre_crc;
for (i = 7; i >= 0; i--) {
cur = ((data >> i) & 0x01) ^ (crc & 0x0001);
bit_1 = cur ^ (crc >> 11 & 0x01);
bit_2 = cur ^ (crc >> 4 & 0x01);
temp = (cur << 4) | (crc >> 12 & 0x0F);
temp = (temp << 7) | (bit_1 << 6) | (crc >> 5 & 0x3F);
temp = (temp << 4) | (bit_2 << 3) | (crc >> 1 & 0x0007);
crc = temp;
}
return crc;
}
static int isc_fw_download(struct mms_ts_info *info, const u8 * data,
size_t len)
{
u8 *buff;
u16 crc_buf;
int src_idx;
int dest_idx;
int ret;
int i, j;
buff = kzalloc(ISC_PKT_SIZE, GFP_KERNEL);
if (!buff) {
dev_err(&info->client->dev, "%s: failed to allocate memory\n",
__func__);
ret = -1;
goto err_mem_alloc;
}
/* enterring ISC mode */
*buff = ISC_ENTER_ISC_DATA;
ret = i2c_smbus_write_byte_data(info->client,
ISC_ENTER_ISC_CMD, *buff);
if (ret < 0) {
dev_err(&info->client->dev,
"fail to enter ISC mode(err=%d)\n", ret);
goto fail_to_isc_enter;
}
usleep_range(10000, 20000);
dev_info(&info->client->dev, "Enter ISC mode\n");
/*enter ISC update mode */
*buff = ISC_ENTER_UPDATE_DATA;
ret = i2c_smbus_write_i2c_block_data(info->client,
ISC_CMD,
ISC_ENTER_UPDATE_DATA_LEN, buff);
if (ret < 0) {
dev_err(&info->client->dev,
"fail to enter ISC update mode(err=%d)\n", ret);
goto fail_to_isc_update;
}
dev_info(&info->client->dev, "Enter ISC update mode\n");
/* firmware write */
*buff = ISC_CMD;
*(buff + 1) = ISC_DATA_WRITE_SUB_CMD;
for (i = 0; i < ISC_PKT_NUM; i++) {
*(buff + 2) = i;
crc_buf = gen_crc(*(buff + 2), ISC_DEFAULT_CRC);
for (j = 0; j < ISC_PKT_DATA_SIZE; j++) {
dest_idx = ISC_PKT_HEADER_SIZE + j;
src_idx = i * ISC_PKT_DATA_SIZE +
((int)(j / WORD_SIZE)) * WORD_SIZE -
(j % WORD_SIZE) + 3;
*(buff + dest_idx) = *(data + src_idx);
crc_buf = gen_crc(*(buff + dest_idx), crc_buf);
}
*(buff + ISC_PKT_DATA_SIZE + ISC_PKT_HEADER_SIZE + 1) =
crc_buf & 0xFF;
*(buff + ISC_PKT_DATA_SIZE + ISC_PKT_HEADER_SIZE) =
crc_buf >> 8 & 0xFF;
ret = i2c_master_send(info->client, buff, ISC_PKT_SIZE);
if (ret < 0) {
dev_err(&info->client->dev,
"fail to firmware writing on packet %d.(%d)\n",
i, ret);
goto fail_to_fw_write;
}
usleep_range(1, 5);
/* confirm CRC */
ret = i2c_smbus_read_byte_data(info->client,
ISC_CHECK_STATUS_CMD);
if (ret == ISC_CONFIRM_CRC) {
dev_info(&info->client->dev,
"updating %dth firmware data packet.\n", i);
} else {
dev_err(&info->client->dev,
"fail to firmware update on %dth (%X).\n",
i, ret);
ret = -1;
goto fail_to_confirm_crc;
}
}
ret = 0;
fail_to_confirm_crc:
fail_to_fw_write:
/* exit ISC mode */
*buff = ISC_EXIT_ISC_SUB_CMD;
*(buff + 1) = ISC_EXIT_ISC_SUB_CMD2;
i2c_smbus_write_i2c_block_data(info->client, ISC_CMD, 2, buff);
usleep_range(10000, 20000);
fail_to_isc_update:
hw_reboot_normal(info);
fail_to_isc_enter:
kfree(buff);
err_mem_alloc:
return ret;
}
#endif /* SEC_TSP_ISC_FW_UPDATE */
static int get_fw_version(struct mms_ts_info *info)
{
int ret;
int retries = 3;
/* this seems to fail sometimes after a reset.. retry a few times */
do {
ret = i2c_smbus_read_byte_data(info->client, MMS_FW_VERSION);
} while (ret < 0 && retries-- > 0);
return ret;
}
static int get_hw_version(struct mms_ts_info *info)
{
int ret;
int retries = 3;
/* this seems to fail sometimes after a reset.. retry a few times */
do {
ret = i2c_smbus_read_byte_data(info->client, MMS_HW_REVISION);
} while (ret < 0 && retries-- > 0);
return ret;
}
static int mms_ts_enable(struct mms_ts_info *info, int wakeupcmd)
{
mutex_lock(&info->lock);
if (info->enabled)
goto out;
/* wake up the touch controller. */
if (wakeupcmd == 1) {
i2c_smbus_write_byte_data(info->client, 0, 0);
usleep_range(3000, 5000);
}
info->enabled = true;
enable_irq(info->irq);
out:
mutex_unlock(&info->lock);
return 0;
}
static int mms_ts_disable(struct mms_ts_info *info, int sleepcmd)
{
mutex_lock(&info->lock);
if (!info->enabled)
goto out;
disable_irq_nosync(info->irq);
if (sleepcmd == 1) {
i2c_smbus_write_byte_data(info->client, MMS_MODE_CONTROL, 0);
usleep_range(10000, 12000);
}
info->enabled = false;
touch_is_pressed = 0;
out:
mutex_unlock(&info->lock);
return 0;
}
static int mms_ts_finish_config(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
int ret;
ret = request_threaded_irq(client->irq, NULL, mms_ts_interrupt,
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
MELFAS_TS_NAME, info);
if (ret < 0) {
ret = 1;
dev_err(&client->dev, "Failed to register interrupt\n");
goto err_req_irq;
}
info->irq = client->irq;
barrier();
dev_info(&client->dev,
"Melfas MMS-series touch controller initialized\n");
return 0;
err_req_irq:
return ret;
}
static int mms_ts_fw_info(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret = 0;
int ver, hw_rev;
ver = get_fw_version(info);
info->fw_ic_ver = ver;
dev_info(&client->dev,
"[TSP]fw version 0x%02x !!!!\n", ver);
hw_rev = get_hw_version(info);
dev_info(&client->dev,
"[TSP] hw rev = %x\n", hw_rev);
if (ver < 0 || hw_rev < 0) {
ret = 1;
dev_err(&client->dev,
"i2c fail...tsp driver unload.\n");
return ret;
}
if (!info->pdata || !info->pdata->mux_fw_flash) {
ret = 1;
dev_err(&client->dev,
"fw cannot be updated, missing platform data\n");
return ret;
}
ret = mms_ts_finish_config(info);
return ret;
}
static int mms_ts_fw_load(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret = 0;
int ver, hw_rev;
int retries = 3;
ver = get_fw_version(info);
info->fw_ic_ver = ver;
dev_info(&client->dev,
"[TSP]fw version 0x%02x !!!!\n", ver);
hw_rev = get_hw_version(info);
dev_info(&client->dev,
"[TSP]hw rev = 0x%02x\n", hw_rev);
pr_err("[TSP] ISC Ver [0x%02x] [0x%02x] [0x%02x]",
i2c_smbus_read_byte_data(info->client, 0xF3),
i2c_smbus_read_byte_data(info->client, 0xF4),
i2c_smbus_read_byte_data(info->client, 0xF5));
if (!info->pdata || !info->pdata->mux_fw_flash) {
ret = 1;
dev_err(&client->dev,
"fw cannot be updated, missing platform data\n");
goto out;
}
/* 4.8" OCTA LCD FW */
if (ver >= FW_VERSION_4_8 && ver != 0xFF\
&& ver != 0x00 && ver != 0x45) {
dev_info(&client->dev,
"4.8 fw version update does not need\n");
goto done;
}
while (retries--) {
ret = mms100_ISC_download_mbinary(info);
ver = get_fw_version(info);
info->fw_ic_ver = ver;
if (ret == 0) {
pr_err("[TSP] mms100_ISC_download_mbinary success");
goto done;
} else {
pr_err("[TSP] mms100_ISC_download_mbinary fail [%d]",
ret);
ret = 1;
}
dev_err(&client->dev, "retrying flashing\n");
}
out:
return ret;
done:
#if ISC_DL_MODE /* ISC_DL_MODE start */
pr_err("[TSP] ISC Ver [0x%02x] [0x%02x] [0x%02x]",
i2c_smbus_read_byte_data(info->client, 0xF3),
i2c_smbus_read_byte_data(info->client, 0xF4),
i2c_smbus_read_byte_data(info->client, 0xF5));
#endif
ret = mms_ts_finish_config(info);
return ret;
}
#ifdef SEC_TSP_FACTORY_TEST
static void set_cmd_result(struct mms_ts_info *info, char *buff, int len)
{
strncat(info->cmd_result, buff, len);
}
static void get_raw_data_all(struct mms_ts_info *info, u8 cmd)
{
u8 w_buf[6];
u8 read_buffer[2]; /* 52 */
int gpio;
int ret;
int i, j;
u32 max_value = 0, min_value = 0;
u32 raw_data;
char buff[TSP_CMD_STR_LEN] = {0};
gpio = info->pdata->gpio_int;
/* gpio = msm_irq_to_gpio(info->irq); */
disable_irq(info->irq);
w_buf[0] = MMS_VSC_CMD; /* vendor specific command id */
w_buf[1] = MMS_VSC_MODE; /* mode of vendor */
w_buf[2] = 0; /* tx line */
w_buf[3] = 0; /* rx line */
w_buf[4] = 0; /* reserved */
w_buf[5] = 0; /* sub command */
if (cmd == MMS_VSC_CMD_EXIT) {
w_buf[5] = MMS_VSC_CMD_EXIT; /* exit test mode */
ret = i2c_smbus_write_i2c_block_data(info->client,
w_buf[0], 5, &w_buf[1]);
if (ret < 0)
goto err_i2c;
enable_irq(info->irq);
msleep(200);
return;
}
/* MMS_VSC_CMD_CM_DELTA or MMS_VSC_CMD_CM_ABS
* this two mode need to enter the test mode
* exit command must be followed by testing.
*/
if (cmd == MMS_VSC_CMD_CM_DELTA || cmd == MMS_VSC_CMD_CM_ABS) {
/* enter the debug mode */
w_buf[2] = 0x0; /* tx */
w_buf[3] = 0x0; /* rx */
w_buf[5] = MMS_VSC_CMD_ENTER;
ret = i2c_smbus_write_i2c_block_data(info->client,
w_buf[0], 5, &w_buf[1]);
if (ret < 0)
goto err_i2c;
/* wating for the interrupt */
while (gpio_get_value(gpio))
udelay(100);
}
for (i = 0; i < RX_NUM; i++) {
for (j = 0; j < TX_NUM; j++) {
w_buf[2] = j; /* tx */
w_buf[3] = i; /* rx */
w_buf[5] = cmd;
ret = i2c_smbus_write_i2c_block_data(info->client,
w_buf[0], 5, &w_buf[1]);
if (ret < 0)
goto err_i2c;
usleep_range(1, 5);
ret = i2c_smbus_read_i2c_block_data(info->client, 0xBF,
2, read_buffer);
if (ret < 0)
goto err_i2c;
raw_data = ((u16) read_buffer[1] << 8) | read_buffer[0];
if (i == 0 && j == 0) {
max_value = min_value = raw_data;
} else {
max_value = max(max_value, raw_data);
min_value = min(min_value, raw_data);
}
if (cmd == MMS_VSC_CMD_INTENSITY) {
info->intensity[i * TX_NUM + j] = raw_data;
dev_dbg(&info->client->dev, "[TSP] intensity[%d][%d] = %d\n",
j, i, info->intensity[i * TX_NUM + j]);
} else if (cmd == MMS_VSC_CMD_CM_DELTA) {
info->inspection[i * TX_NUM + j] = raw_data;
dev_dbg(&info->client->dev, "[TSP] delta[%d][%d] = %d\n",
j, i, info->inspection[i * TX_NUM + j]);
} else if (cmd == MMS_VSC_CMD_CM_ABS) {
info->raw[i * TX_NUM + j] = raw_data;
dev_dbg(&info->client->dev, "[TSP] raw[%d][%d] = %d\n",
j, i, info->raw[i * TX_NUM + j]);
} else if (cmd == MMS_VSC_CMD_REFER) {
info->reference[i * TX_NUM + j] =
raw_data >> 3;
dev_dbg(&info->client->dev, "[TSP] reference[%d][%d] = %d\n",
j, i, info->reference[i * TX_NUM + j]);
}
}
}
snprintf(buff, sizeof(buff), "%d,%d", min_value, max_value);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
enable_irq(info->irq);
err_i2c:
dev_err(&info->client->dev, "%s: fail to i2c (cmd=%d)\n",
__func__, cmd);
}
static u32 get_raw_data_one(struct mms_ts_info *info, u16 rx_idx, u16 tx_idx,
u8 cmd)
{
u8 w_buf[6];
u8 read_buffer[2];
int ret;
u32 raw_data;
w_buf[0] = MMS_VSC_CMD; /* vendor specific command id */
w_buf[1] = MMS_VSC_MODE; /* mode of vendor */
w_buf[2] = 0; /* tx line */
w_buf[3] = 0; /* rx line */
w_buf[4] = 0; /* reserved */
w_buf[5] = 0; /* sub command */
if (cmd != MMS_VSC_CMD_INTENSITY && cmd != MMS_VSC_CMD_RAW &&
cmd != MMS_VSC_CMD_REFER) {
dev_err(&info->client->dev, "%s: not profer command(cmd=%d)\n",
__func__, cmd);
return FAIL;
}
w_buf[2] = tx_idx; /* tx */
w_buf[3] = rx_idx; /* rx */
w_buf[5] = cmd; /* sub command */
ret = i2c_smbus_write_i2c_block_data(info->client, w_buf[0], 5,
&w_buf[1]);
if (ret < 0)
goto err_i2c;
ret = i2c_smbus_read_i2c_block_data(info->client, 0xBF, 2, read_buffer);
if (ret < 0)
goto err_i2c;
raw_data = ((u16) read_buffer[1] << 8) | read_buffer[0];
if (cmd == MMS_VSC_CMD_REFER)
raw_data = raw_data >> 4;
return raw_data;
err_i2c:
dev_err(&info->client->dev, "%s: fail to i2c (cmd=%d)\n",
__func__, cmd);
return FAIL;
}
static ssize_t show_close_tsp_test(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
get_raw_data_all(info, MMS_VSC_CMD_EXIT);
info->ft_flag = 0;
return snprintf(buf, TSP_BUF_SIZE, "%u\n", 0);
}
static void set_default_result(struct mms_ts_info *info)
{
char delim = ':';
memset(info->cmd_result, 0x00, ARRAY_SIZE(info->cmd_result));
memcpy(info->cmd_result, info->cmd, strlen(info->cmd));
strncat(info->cmd_result, &delim, 1);
}
static int check_rx_tx_num(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[TSP_CMD_STR_LEN] = {0};
int node;
if (info->cmd_param[0] < 0 ||
info->cmd_param[0] >= TX_NUM ||
info->cmd_param[1] < 0 ||
info->cmd_param[1] >= RX_NUM) {
snprintf(buff, sizeof(buff) , "%s", "NG");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 3;
dev_info(&info->client->dev, "%s: parameter error: %u,%u\n",
__func__, info->cmd_param[0],
info->cmd_param[1]);
node = -1;
return node;
}
node = info->cmd_param[1] * TX_NUM + info->cmd_param[0];
dev_info(&info->client->dev, "%s: node = %d\n", __func__,
node);
return node;
}
static void not_support_cmd(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
set_default_result(info);
sprintf(buff, "%s", "NA");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 4;
dev_info(&info->client->dev, "%s: \"%s(%d)\"\n", __func__,
buff, strnlen(buff, sizeof(buff)));
return;
}
static void fw_update(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
struct i2c_client *client = info->client;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret = 0;
int ver = 0, fw_bin_ver = 0;
int retries = 5;
const u8 *buff = 0;
mm_segment_t old_fs = {0};
struct file *fp = NULL;
long fsize = 0, nread = 0;
char fw_path[MAX_FW_PATH+1];
char result[16] = {0};
set_default_result(info);
dev_info(&client->dev,
"fw_ic_ver = 0x%02x, fw_bin_ver = 0x%02x\n",
info->fw_ic_ver, fw_bin_ver);
switch (info->cmd_param[0]) {
case BUILT_IN:
dev_info(&client->dev, "built in 4.8 fw is loaded!!\n");
while (retries--) {
ret = mms100_ISC_download_mbinary(info);
ver = get_fw_version(info);
info->fw_ic_ver = ver;
if (ret == 0) {
pr_err("[TSP] mms100_ISC_download_mbinary success");
info->cmd_state = 2;
return;
} else {
pr_err("[TSP] mms100_ISC_download_mbinary fail[%d]",
ret);
info->cmd_state = 3;
}
}
return;
break;
case UMS:
old_fs = get_fs();
set_fs(get_ds());
snprintf(fw_path, MAX_FW_PATH, "/sdcard/%s", TSP_FW_FILENAME);
fp = filp_open(fw_path, O_RDONLY, 0);
if (IS_ERR(fp)) {
dev_err(&client->dev,
"file %s open error:%d\n", fw_path, (s32)fp);
info->cmd_state = 3;
goto err_open;
}
fsize = fp->f_path.dentry->d_inode->i_size;
buff = kzalloc((size_t)fsize, GFP_KERNEL);
if (!buff) {
dev_err(&client->dev, "fail to alloc buffer for fw\n");
info->cmd_state = 3;
goto err_alloc;
}
nread = vfs_read(fp, (char __user *)buff, fsize, &fp->f_pos);
if (nread != fsize) {
/*dev_err("fail to read file %s (nread = %d)\n",
fw_path, nread);*/
info->cmd_state = 3;
goto err_fw_size;
}
filp_close(fp, current->files);
set_fs(old_fs);
dev_info(&client->dev, "ums fw is loaded!!\n");
break;
default:
dev_err(&client->dev, "invalid fw file type!!\n");
goto not_support;
}
disable_irq(info->irq);
while (retries--) {
i2c_lock_adapter(adapter);
info->pdata->mux_fw_flash(true);
ret = fw_download(info, (const u8 *)buff,
(const size_t)fsize);
info->pdata->mux_fw_flash(false);
i2c_unlock_adapter(adapter);
if (ret < 0) {
dev_err(&client->dev, "retrying flashing\n");
continue;
}
ver = get_fw_version(info);
info->fw_ic_ver = ver;
if (info->cmd_param[0] == 1 || info->cmd_param[0] == 2) {
dev_info(&client->dev,
"fw update done. ver = 0x%02x\n", ver);
info->cmd_state = 2;
snprintf(result, sizeof(result) , "%s", "OK");
set_cmd_result(info, result,
strnlen(result, sizeof(result)));
enable_irq(info->irq);
kfree(buff);
return;
} else if (ver == fw_bin_ver) {
dev_info(&client->dev,
"fw update done. ver = 0x%02x\n", ver);
info->cmd_state = 2;
snprintf(result, sizeof(result) , "%s", "OK");
set_cmd_result(info, result,
strnlen(result, sizeof(result)));
enable_irq(info->irq);
return;
} else {
dev_err(&client->dev,
"ERROR : fw version is still wrong (0x%x != 0x%x)\n",
ver, fw_bin_ver);
}
dev_err(&client->dev, "retrying flashing\n");
}
if (fp != NULL) {
err_fw_size:
kfree(buff);
err_alloc:
filp_close(fp, NULL);
err_open:
set_fs(old_fs);
}
not_support:
do_not_need_update:
snprintf(result, sizeof(result) , "%s", "NG");
set_cmd_result(info, result, strnlen(result, sizeof(result)));
return;
}
static void get_fw_ver_bin(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int hw_rev;
set_default_result(info);
snprintf(buff, sizeof(buff), "%#02x", FW_VERSION_4_8);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_fw_ver_ic(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int ver;
set_default_result(info);
ver = info->fw_ic_ver;
snprintf(buff, sizeof(buff), "%#02x", ver);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_config_ver(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[20] = {0};
set_default_result(info);
snprintf(buff, sizeof(buff), "%s", info->config_fw_version);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_threshold(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int threshold;
set_default_result(info);
threshold = i2c_smbus_read_byte_data(info->client, 0x05);
if (threshold < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 3;
return;
}
snprintf(buff, sizeof(buff), "%d", threshold);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
/*
static void module_off_master(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[3] = {0};
mutex_lock(&info->lock);
if (info->enabled) {
disable_irq(info->irq);
info->enabled = false;
touch_is_pressed = 0;
}
mutex_unlock(&info->lock);
info->pdata->power(0);
if (info->pdata->is_vdd_on() == 0)
snprintf(buff, sizeof(buff), "%s", "OK");
else
snprintf(buff, sizeof(buff), "%s", "NG");
set_default_result(info);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
if (strncmp(buff, "OK", 2) == 0)
info->cmd_state = 2;
else
info->cmd_state = 3;
dev_info(&info->client->dev, "%s: %s\n", __func__, buff);
}
static void module_on_master(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[3] = {0};
mms_pwr_on_reset(info);
mutex_lock(&info->lock);
if (!info->enabled) {
enable_irq(info->irq);
info->enabled = true;
}
mutex_unlock(&info->lock);
if (info->pdata->is_vdd_on() == 1)
snprintf(buff, sizeof(buff), "%s", "OK");
else
snprintf(buff, sizeof(buff), "%s", "NG");
set_default_result(info);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
if (strncmp(buff, "OK", 2) == 0)
info->cmd_state = 2;
else
info->cmd_state = 3;
dev_info(&info->client->dev, "%s: %s\n", __func__, buff);
}
static void module_off_slave(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
not_support_cmd(info);
}
static void module_on_slave(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
not_support_cmd(info);
}
*/
static void get_chip_vendor(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
set_default_result(info);
snprintf(buff, sizeof(buff), "%s", "MELFAS");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_chip_name(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
set_default_result(info);
snprintf(buff, sizeof(buff), "%s", "MMS144");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_reference(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
unsigned int val;
int node;
set_default_result(info);
node = check_rx_tx_num(info);
if (node < 0)
return;
val = info->reference[node];
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_cm_abs(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
unsigned int val;
int node;
set_default_result(info);
node = check_rx_tx_num(info);
if (node < 0)
return;
val = info->raw[node];
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void get_cm_delta(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
unsigned int val;
int node;
set_default_result(info);
node = check_rx_tx_num(info);
if (node < 0)
return;
val = info->inspection[node];
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void get_intensity(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
unsigned int val;
int node;
set_default_result(info);
node = check_rx_tx_num(info);
if (node < 0)
return;
val = info->intensity[node];
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void get_x_num(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int val;
set_default_result(info);
val = i2c_smbus_read_byte_data(info->client, 0xEF);
if (val < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 3;
dev_info(&info->client->dev,
"%s: fail to read num of x (%d).\n", __func__, val);
return;
}
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void get_y_num(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int val;
set_default_result(info);
val = i2c_smbus_read_byte_data(info->client, 0xEE);
if (val < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 3;
dev_info(&info->client->dev,
"%s: fail to read num of y (%d).\n", __func__, val);
return;
}
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void run_reference_read(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
set_default_result(info);
get_raw_data_all(info, MMS_VSC_CMD_REFER);
info->cmd_state = 2;
/* dev_info(&info->client->dev, "%s: %s(%d)\n", __func__); */
}
static void run_cm_abs_read(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
set_default_result(info);
get_raw_data_all(info, MMS_VSC_CMD_CM_ABS);
get_raw_data_all(info, MMS_VSC_CMD_EXIT);
info->cmd_state = 2;
/* dev_info(&info->client->dev, "%s: %s(%d)\n", __func__); */
}
static void run_cm_delta_read(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
set_default_result(info);
get_raw_data_all(info, MMS_VSC_CMD_CM_DELTA);
get_raw_data_all(info, MMS_VSC_CMD_EXIT);
info->cmd_state = 2;
/* dev_info(&info->client->dev, "%s: %s(%d)\n", __func__); */
}
static void run_intensity_read(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
set_default_result(info);
get_raw_data_all(info, MMS_VSC_CMD_INTENSITY);
info->cmd_state = 2;
/* dev_info(&info->client->dev, "%s: %s(%d)\n", __func__); */
}
static ssize_t store_cmd(struct device *dev, struct device_attribute
*devattr, const char *buf, size_t count)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
struct i2c_client *client = info->client;
char *cur, *start, *end;
char buff[TSP_CMD_STR_LEN] = {0};
int len, i;
struct tsp_cmd *tsp_cmd_ptr = NULL;
char delim = ',';
bool cmd_found = false;
int param_cnt = 0;
int ret;
if (info->cmd_is_running == true) {
dev_err(&info->client->dev, "tsp_cmd: other cmd is running.\n");
goto err_out;
}
/* check lock */
mutex_lock(&info->cmd_lock);
info->cmd_is_running = true;
mutex_unlock(&info->cmd_lock);
info->cmd_state = 1;
for (i = 0; i < ARRAY_SIZE(info->cmd_param); i++)
info->cmd_param[i] = 0;
len = (int)count;
if (*(buf + len - 1) == '\n')
len--;
memset(info->cmd, 0x00, ARRAY_SIZE(info->cmd));
memcpy(info->cmd, buf, len);
cur = strchr(buf, (int)delim);
if (cur)
memcpy(buff, buf, cur - buf);
else
memcpy(buff, buf, len);
/* find command */
list_for_each_entry(tsp_cmd_ptr, &info->cmd_list_head, list) {
if (!strcmp(buff, tsp_cmd_ptr->cmd_name)) {
cmd_found = true;
break;
}
}
/* set not_support_cmd */
if (!cmd_found) {
list_for_each_entry(tsp_cmd_ptr, &info->cmd_list_head, list) {
if (!strcmp("not_support_cmd", tsp_cmd_ptr->cmd_name))
break;
}
}
/* parsing parameters */
if (cur && cmd_found) {
cur++;
start = cur;
memset(buff, 0x00, ARRAY_SIZE(buff));
do {
if (*cur == delim || cur - buf == len) {
end = cur;
memcpy(buff, start, end - start);
*(buff + strlen(buff)) = '\0';
ret = kstrtoint(buff, 10,\
info->cmd_param + param_cnt);
start = cur + 1;
memset(buff, 0x00, ARRAY_SIZE(buff));
param_cnt++;
}
cur++;
} while (cur - buf <= len);
}
dev_info(&client->dev, "cmd = %s\n", tsp_cmd_ptr->cmd_name);
for (i = 0; i < param_cnt; i++)
dev_info(&client->dev, "cmd param %d= %d\n", i,
info->cmd_param[i]);
tsp_cmd_ptr->cmd_func(info);
err_out:
return count;
}
static ssize_t show_cmd_status(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
char buff[16] = {0};
dev_info(&info->client->dev, "tsp cmd: status:%d\n",
info->cmd_state);
if (info->cmd_state == 0)
snprintf(buff, sizeof(buff), "WAITING");
else if (info->cmd_state == 1)
snprintf(buff, sizeof(buff), "RUNNING");
else if (info->cmd_state == 2)
snprintf(buff, sizeof(buff), "OK");
else if (info->cmd_state == 3)
snprintf(buff, sizeof(buff), "FAIL");
else if (info->cmd_state == 4)
snprintf(buff, sizeof(buff), "NOT_APPLICABLE");
return snprintf(buf, TSP_BUF_SIZE, "%s\n", buff);
}
static ssize_t show_cmd_result(struct device *dev, struct device_attribute
*devattr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
dev_info(&info->client->dev, "tsp cmd: result: %s\n", info->cmd_result);
mutex_lock(&info->cmd_lock);
info->cmd_is_running = false;
mutex_unlock(&info->cmd_lock);
info->cmd_state = 0;
return snprintf(buf, TSP_BUF_SIZE, "%s\n", info->cmd_result);
}
#ifdef ESD_DEBUG
static bool intensity_log_flag;
static ssize_t show_intensity_logging_on(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
struct i2c_client *client = info->client;
struct file *fp;
char log_data[160] = { 0, };
char buff[16] = { 0, };
mm_segment_t old_fs;
long nwrite;
u32 val;
int i, y, c;
old_fs = get_fs();
set_fs(KERNEL_DS);
#define MELFAS_DEBUG_LOG_PATH "/sdcard/melfas_log"
dev_info(&client->dev, "%s: start.\n", __func__);
fp = filp_open(MELFAS_DEBUG_LOG_PATH, O_RDWR | O_CREAT,
S_IRWXU | S_IRWXG | S_IRWXO);
if (IS_ERR(fp)) {
dev_err(&client->dev, "%s: fail to open log file\n", __func__);
goto open_err;
}
intensity_log_flag = 1;
do {
for (y = 0; y < 3; y++) {
/* for tx chanel 0~2 */
memset(log_data, 0x00, 160);
snprintf(buff, 16, "%1u: ", y);
strncat(log_data, buff, strnlen(buff, 16));
for (i = 0; i < RX_NUM; i++) {
val = get_raw_data_one(info, i, y,
MMS_VSC_CMD_INTENSITY);
snprintf(buff, 16, "%5u, ", val);
strncat(log_data, buff, strnlen(buff, 16));
}
memset(buff, '\n', 2);
c = (y == 2) ? 2 : 1;
strncat(log_data, buff, c);
nwrite = vfs_write(fp, (const char __user *)log_data,
strnlen(log_data, 160), &fp->f_pos);
}
usleep_range(5000);
} while (intensity_log_flag);
filp_close(fp, current->files);
set_fs(old_fs);
return 0;
open_err:
set_fs(old_fs);
return FAIL;
}
static ssize_t show_intensity_logging_off(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
intensity_log_flag = 0;
usleep_range(10000);
get_raw_data_all(info, MMS_VSC_CMD_EXIT);
return 0;
}
#endif
static DEVICE_ATTR(close_tsp_test, S_IRUGO, show_close_tsp_test, NULL);
static DEVICE_ATTR(cmd, S_IWUSR | S_IWGRP, NULL, store_cmd);
static DEVICE_ATTR(cmd_status, S_IRUGO, show_cmd_status, NULL);
static DEVICE_ATTR(cmd_result, S_IRUGO, show_cmd_result, NULL);
#ifdef ESD_DEBUG
static DEVICE_ATTR(intensity_logging_on, S_IRUGO, show_intensity_logging_on,
NULL);
static DEVICE_ATTR(intensity_logging_off, S_IRUGO, show_intensity_logging_off,
NULL);
#endif
static struct attribute *sec_touch_facotry_attributes[] = {
&dev_attr_close_tsp_test.attr,
&dev_attr_cmd.attr,
&dev_attr_cmd_status.attr,
&dev_attr_cmd_result.attr,
#ifdef ESD_DEBUG
&dev_attr_intensity_logging_on.attr,
&dev_attr_intensity_logging_off.attr,
#endif
NULL,
};
static struct attribute_group sec_touch_factory_attr_group = {
.attrs = sec_touch_facotry_attributes,
};
#endif /* SEC_TSP_FACTORY_TEST */
static int __devinit mms_ts_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct mms_ts_info *info;
struct input_dev *input_dev;
int ret = 0;
char buf[4] = { 0, };
#ifdef SEC_TSP_FACTORY_TEST
int i;
struct device *fac_dev_ts;
#endif
touch_is_pressed = 0;
#if 0
gpio_request(GPIO_OLED_DET, "OLED_DET");
ret = gpio_get_value(GPIO_OLED_DET);
printk(KERN_DEBUG
"[TSP] OLED_DET = %d\n", ret);
if (ret == 0) {
printk(KERN_DEBUG
"[TSP] device wasn't connected to board\n");
return -EIO;
}
#endif
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
return -EIO;
info = kzalloc(sizeof(struct mms_ts_info), GFP_KERNEL);
if (!info) {
dev_err(&client->dev, "Failed to allocate memory\n");
ret = -ENOMEM;
goto err_alloc;
}
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&client->dev, "Failed to allocate memory for input device\n");
ret = -ENOMEM;
goto err_input_alloc;
}
info->client = client;
info->input_dev = input_dev;
info->pdata = client->dev.platform_data;
if (NULL == info->pdata) {
pr_err("failed to get platform data\n");
goto err_reg_input_dev;
}
info->irq = -1;
mutex_init(&info->lock);
if (info->pdata) {
info->max_x = info->pdata->max_x;
info->max_y = info->pdata->max_y;
info->invert_x = info->pdata->invert_x;
info->invert_y = info->pdata->invert_y;
info->config_fw_version = info->pdata->config_fw_version;
info->register_cb = info->pdata->register_cb;
} else {
info->max_x = 720;
info->max_y = 1280;
}
snprintf(info->phys, sizeof(info->phys),
"%s/input0", dev_name(&client->dev));
input_dev->name = "sec_touchscreen"; /*= "Melfas MMSxxx Touchscreen";*/
input_dev->phys = info->phys;
input_dev->id.bustype = BUS_I2C;
input_dev->dev.parent = &client->dev;
__set_bit(EV_ABS, input_dev->evbit);
__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
input_mt_init_slots(input_dev, MAX_FINGERS);
input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR,
0, MAX_WIDTH, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_X,
0, (info->max_x)-1, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
0, (info->max_y)-1, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
0, MAX_PRESSURE, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR,
0, MAX_PRESSURE, 0, 0);
input_set_abs_params(input_dev, ABS_MT_ANGLE,
MIN_ANGLE, MAX_ANGLE, 0, 0);
input_set_abs_params(input_dev, ABS_MT_PALM,
0, 1, 0, 0);
input_set_drvdata(input_dev, info);
ret = input_register_device(input_dev);
if (ret) {
dev_err(&client->dev, "failed to register input dev (%d)\n",
ret);
goto err_reg_input_dev;
}
#if TOUCH_BOOSTER
mutex_init(&info->dvfs_lock);
INIT_DELAYED_WORK(&info->work_dvfs_off, set_dvfs_off);
INIT_DELAYED_WORK(&info->work_dvfs_chg, change_dvfs_lock);
bus_dev = dev_get("exynos-busfreq");
info->cpufreq_level = -1;
info->dvfs_lock_status = false;
#endif
i2c_set_clientdata(client, info);
info->pdata->power(true);
msleep(100);
ret = i2c_master_recv(client, buf, 1);
if (ret < 0) { /* tsp connect check */
pr_err("%s: i2c fail...tsp driver unload [%d], Add[%d]\n",
__func__, ret, info->client->addr);
goto err_config;
}
ret = mms_ts_fw_load(info);
/* ret = mms_ts_fw_info(info); */
if (ret) {
dev_err(&client->dev, "failed to initialize (%d)\n", ret);
goto err_config;
}
info->enabled = true;
info->callbacks.inform_charger = melfas_ta_cb;
if (info->register_cb)
info->register_cb(&info->callbacks);
#ifdef CONFIG_HAS_EARLYSUSPEND
info->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
info->early_suspend.suspend = mms_ts_early_suspend;
info->early_suspend.resume = mms_ts_late_resume;
register_early_suspend(&info->early_suspend);
#endif
sec_touchscreen = device_create(sec_class,
NULL, 0, info, "sec_touchscreen");
if (IS_ERR(sec_touchscreen)) {
dev_err(&client->dev,
"Failed to create device for the sysfs1\n");
ret = -ENODEV;
}
#ifdef SEC_TSP_FACTORY_TEST
INIT_LIST_HEAD(&info->cmd_list_head);
for (i = 0; i < ARRAY_SIZE(tsp_cmds); i++)
list_add_tail(&tsp_cmds[i].list, &info->cmd_list_head);
mutex_init(&info->cmd_lock);
info->cmd_is_running = false;
fac_dev_ts = device_create(sec_class,
NULL, 0, info, "tsp");
if (IS_ERR(fac_dev_ts))
dev_err(&client->dev, "Failed to create device for the sysfs\n");
ret = sysfs_create_group(&fac_dev_ts->kobj,
&sec_touch_factory_attr_group);
if (ret)
dev_err(&client->dev, "Failed to create sysfs group\n");
#endif
return 0;
err_config:
input_unregister_device(input_dev);
err_reg_input_dev:
input_free_device(input_dev);
err_input_alloc:
input_dev = NULL;
kfree(info);
err_alloc:
return ret;
}
static int __devexit mms_ts_remove(struct i2c_client *client)
{
struct mms_ts_info *info = i2c_get_clientdata(client);
unregister_early_suspend(&info->early_suspend);
if (info->irq >= 0)
free_irq(info->irq, info);
input_unregister_device(info->input_dev);
kfree(info);
return 0;
}
#if defined(CONFIG_PM) || defined(CONFIG_HAS_EARLYSUSPEND)
static int mms_ts_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct mms_ts_info *info = i2c_get_clientdata(client);
if (!info->enabled)
return 0;
dev_notice(&info->client->dev, "%s: users=%d\n", __func__,
info->input_dev->users);
disable_irq(info->irq);
info->enabled = false;
touch_is_pressed = 0;
release_all_fingers(info);
info->pdata->power(false);
/* This delay needs to prevent unstable POR by
rapid frequently pressing of PWR key. */
msleep(50);
return 0;
}
static int mms_ts_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct mms_ts_info *info = i2c_get_clientdata(client);
int ret = 0;
if (info->enabled)
return 0;
dev_notice(&info->client->dev, "%s: users=%d\n", __func__,
info->input_dev->users);
info->pdata->power(true);
msleep(120);
if (info->ta_status) {
dev_notice(&client->dev, "TA connect!!!\n");
i2c_smbus_write_byte_data(info->client, 0x33, 0x1);
} else {
dev_notice(&client->dev, "TA disconnect!!!\n");
i2c_smbus_write_byte_data(info->client, 0x33, 0x2);
}
/* Because irq_type by EXT_INTxCON register is changed to low_level
* after wakeup, irq_type set to falling edge interrupt again.
*/
enable_irq(info->irq);
info->enabled = true;
mms_set_noise_mode(info);
return 0;
}
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
static void mms_ts_early_suspend(struct early_suspend *h)
{
struct mms_ts_info *info;
info = container_of(h, struct mms_ts_info, early_suspend);
mms_ts_suspend(&info->client->dev);
}
static void mms_ts_late_resume(struct early_suspend *h)
{
struct mms_ts_info *info;
info = container_of(h, struct mms_ts_info, early_suspend);
mms_ts_resume(&info->client->dev);
}
#endif
#if defined(CONFIG_PM) && !defined(CONFIG_HAS_EARLYSUSPEND)
static const struct dev_pm_ops mms_ts_pm_ops = {
.suspend = mms_ts_suspend,
.resume = mms_ts_resume,
#ifdef CONFIG_HIBERNATION
.freeze = mms_ts_suspend,
.thaw = mms_ts_resume,
.restore = mms_ts_resume,
#endif
};
#endif
static const struct i2c_device_id mms_ts_id[] = {
{MELFAS_TS_NAME, 0},
{}
};
MODULE_DEVICE_TABLE(i2c, mms_ts_id);
static struct i2c_driver mms_ts_driver = {
.probe = mms_ts_probe,
.remove = __devexit_p(mms_ts_remove),
.driver = {
.name = MELFAS_TS_NAME,
#if defined(CONFIG_PM) && !defined(CONFIG_HAS_EARLYSUSPEND)
.pm = &mms_ts_pm_ops,
#endif
},
.id_table = mms_ts_id,
};
static int __init mms_ts_init(void)
{
return i2c_add_driver(&mms_ts_driver);
}
static void __exit mms_ts_exit(void)
{
i2c_del_driver(&mms_ts_driver);
}
module_init(mms_ts_init);
module_exit(mms_ts_exit);
/* Module information */
MODULE_DESCRIPTION("Touchscreen driver for Melfas MMS-series controllers");
MODULE_LICENSE("GPL");
| Java |
<html lang="en">
<head>
<title>Expressions - Using as</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Using as">
<meta name="generator" content="makeinfo 4.8">
<link title="Top" rel="start" href="index.html#Top">
<link rel="prev" href="Symbols.html#Symbols" title="Symbols">
<link rel="next" href="Pseudo-Ops.html#Pseudo-Ops" title="Pseudo Ops">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<!--
This file documents the GNU Assembler "as".
Copyright (C) 1991-2018 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3
or any later version published by the Free Software Foundation;
with no Invariant Sections, with no Front-Cover Texts, and with no
Back-Cover Texts. A copy of the license is included in the
section entitled ``GNU Free Documentation License''.
-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
pre.display { font-family:inherit }
pre.format { font-family:inherit }
pre.smalldisplay { font-family:inherit; font-size:smaller }
pre.smallformat { font-family:inherit; font-size:smaller }
pre.smallexample { font-size:smaller }
pre.smalllisp { font-size:smaller }
span.sc { font-variant:small-caps }
span.roman { font-family:serif; font-weight:normal; }
span.sansserif { font-family:sans-serif; font-weight:normal; }
--></style>
</head>
<body>
<div class="node">
<p>
<a name="Expressions"></a>
Next: <a rel="next" accesskey="n" href="Pseudo-Ops.html#Pseudo-Ops">Pseudo Ops</a>,
Previous: <a rel="previous" accesskey="p" href="Symbols.html#Symbols">Symbols</a>,
Up: <a rel="up" accesskey="u" href="index.html#Top">Top</a>
<hr>
</div>
<h2 class="chapter">6 Expressions</h2>
<p><a name="index-expressions-243"></a><a name="index-addresses-244"></a><a name="index-numeric-values-245"></a>An <dfn>expression</dfn> specifies an address or numeric value.
Whitespace may precede and/or follow an expression.
<p>The result of an expression must be an absolute number, or else an offset into
a particular section. If an expression is not absolute, and there is not
enough information when <samp><span class="command">as</span></samp> sees the expression to know its
section, a second pass over the source program might be necessary to interpret
the expression—but the second pass is currently not implemented.
<samp><span class="command">as</span></samp> aborts with an error message in this situation.
<ul class="menu">
<li><a accesskey="1" href="Empty-Exprs.html#Empty-Exprs">Empty Exprs</a>: Empty Expressions
<li><a accesskey="2" href="Integer-Exprs.html#Integer-Exprs">Integer Exprs</a>: Integer Expressions
</ul>
</body></html>
| Java |
#userIcon.hear {
-fx-image: url(../img/eye.png);
}
#userIcon.me {
-fx-image: url(../img/eye.png);
-fx-opacity: 0.1;
}
#userIcon.me:hover {
-fx-image: url(../img/eye.png);
-fx-opacity: 0.3;
}
#userIcon.master {
-fx-image: url(../img/crown.png);
}
#userItem {
-fx-background-color: #E4F6F9;
-fx-background-radius: 10;
}
Label {
-fx-text-fill: #8EBDC4;
} | Java |
#!/bin/sh
# Copyright (C) 2012 Red Hat, Inc. All rights reserved.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions
# of the GNU General Public License v.2.
#
# 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-1307 USA
. lib/inittest
test -e LOCAL_LVMETAD || skip
aux prepare_devs 2
pvcreate --metadatatype 1 "$dev1"
should vgscan --cache
pvs | should grep "$dev1"
vgcreate --metadatatype 1 $vg1 "$dev1"
should vgscan --cache
vgs | should grep $vg1
pvs | should grep "$dev1"
# check for RHBZ 1080189 -- SEGV in lvremove/vgremove
pvcreate -ff -y --metadatatype 1 "$dev1" "$dev2"
vgcreate --metadatatype 1 $vg1 "$dev1" "$dev2"
lvcreate -l1 $vg1
pvremove -ff -y "$dev2"
vgchange -an $vg1
not lvremove $vg1
not vgremove -ff -y $vg1
| Java |
/* $Id$ */
/*
Copyright (C) 2003 - 2013 by David White <dave@whitevine.net>
Part of the Battle for Wesnoth Project http://www.wesnoth.org/
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.
See the COPYING file for more details.
*/
#ifndef VIDEO_HPP_INCLUDED
#define VIDEO_HPP_INCLUDED
#include "events.hpp"
#include "exceptions.hpp"
#include "lua_jailbreak_exception.hpp"
#include <boost/utility.hpp>
struct surface;
//possible flags when setting video modes
#define FULL_SCREEN SDL_FULLSCREEN
surface display_format_alpha(surface surf);
surface get_video_surface();
SDL_Rect screen_area();
bool non_interactive();
//which areas of the screen will be updated when the buffer is flipped?
void update_rect(size_t x, size_t y, size_t w, size_t h);
void update_rect(const SDL_Rect& rect);
void update_whole_screen();
class CVideo : private boost::noncopyable {
public:
enum FAKE_TYPES {
NO_FAKE,
FAKE,
FAKE_TEST
};
CVideo(FAKE_TYPES type = NO_FAKE);
~CVideo();
int bppForMode( int x, int y, int flags);
int modePossible( int x, int y, int bits_per_pixel, int flags, bool current_screen_optimal=false);
int setMode( int x, int y, int bits_per_pixel, int flags );
//did the mode change, since the last call to the modeChanged() method?
bool modeChanged();
//functions to get the dimensions of the current video-mode
int getx() const;
int gety() const;
//blits a surface with black as alpha
void blit_surface(int x, int y, surface surf, SDL_Rect* srcrect=NULL, SDL_Rect* clip_rect=NULL);
void flip();
surface& getSurface();
bool isFullScreen() const;
struct error : public game::error
{
error() : game::error("Video initialization failed") {}
};
class quit
: public tlua_jailbreak_exception
{
public:
quit()
: tlua_jailbreak_exception()
{
}
private:
IMPLEMENT_LUA_JAILBREAK_EXCEPTION(quit)
};
//functions to allow changing video modes when 16BPP is emulated
void setBpp( int bpp );
int getBpp();
void make_fake();
/**
* Creates a fake frame buffer for the unit tests.
*
* @param width The width of the buffer.
* @param height The height of the buffer.
* @param bpp The bpp of the buffer.
*/
void make_test_fake(const unsigned width = 1024,
const unsigned height = 768, const unsigned bpp = 32);
bool faked() const { return fake_screen_; }
//functions to set and clear 'help strings'. A 'help string' is like a tooltip, but it appears
//at the bottom of the screen, so as to not be intrusive. Setting a help string sets what
//is currently displayed there.
int set_help_string(const std::string& str);
void clear_help_string(int handle);
void clear_all_help_strings();
//function to stop the screen being redrawn. Anything that happens while
//the update is locked will be hidden from the user's view.
//note that this function is re-entrant, meaning that if lock_updates(true)
//is called twice, lock_updates(false) must be called twice to unlock
//updates.
void lock_updates(bool value);
bool update_locked() const;
private:
void initSDL();
bool mode_changed_;
int bpp_; // Store real bits per pixel
//if there is no display at all, but we 'fake' it for clients
bool fake_screen_;
//variables for help strings
int help_string_;
int updatesLocked_;
};
//an object which will lock the display for the duration of its lifetime.
struct update_locker
{
update_locker(CVideo& v, bool lock=true) : video(v), unlock(lock) {
if(lock) {
video.lock_updates(true);
}
}
~update_locker() {
unlock_update();
}
void unlock_update() {
if(unlock) {
video.lock_updates(false);
unlock = false;
}
}
private:
CVideo& video;
bool unlock;
};
class resize_monitor : public events::pump_monitor {
void process(events::pump_info &info);
};
//an object which prevents resizing of the screen occurring during
//its lifetime.
struct resize_lock {
resize_lock();
~resize_lock();
};
#endif
| Java |
/*
* Fast Userspace Mutexes (which I call "Futexes!").
* (C) Rusty Russell, IBM 2002
*
* Generalized futexes, futex requeueing, misc fixes by Ingo Molnar
* (C) Copyright 2003 Red Hat Inc, All Rights Reserved
*
* Removed page pinning, fix privately mapped COW pages and other cleanups
* (C) Copyright 2003, 2004 Jamie Lokier
*
* Robust futex support started by Ingo Molnar
* (C) Copyright 2006 Red Hat Inc, All Rights Reserved
* Thanks to Thomas Gleixner for suggestions, analysis and fixes.
*
* PI-futex support started by Ingo Molnar and Thomas Gleixner
* Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
* Copyright (C) 2006 Timesys Corp., Thomas Gleixner <tglx@timesys.com>
*
* PRIVATE futexes by Eric Dumazet
* Copyright (C) 2007 Eric Dumazet <dada1@cosmosbay.com>
*
* Requeue-PI support by Darren Hart <dvhltc@us.ibm.com>
* Copyright (C) IBM Corporation, 2009
* Thanks to Thomas Gleixner for conceptual design and careful reviews.
*
* Thanks to Ben LaHaise for yelling "hashed waitqueues" loudly
* enough at me, Linus for the original (flawed) idea, Matthew
* Kirkwood for proof-of-concept implementation.
*
* "The futexes are also cursed."
* "But they come in a choice of three flavours!"
*
* 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-1307 USA
*/
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/jhash.h>
#include <linux/init.h>
#include <linux/futex.h>
#include <linux/mount.h>
#include <linux/pagemap.h>
#include <linux/syscalls.h>
#include <linux/signal.h>
#include <linux/export.h>
#include <linux/magic.h>
#include <linux/pid.h>
#include <linux/nsproxy.h>
#include <linux/ptrace.h>
#include <linux/sched/rt.h>
#include <linux/freezer.h>
#include <linux/hugetlb.h>
#include <asm/futex.h>
#include "rtmutex_common.h"
#ifndef CONFIG_HAVE_FUTEX_CMPXCHG
int __read_mostly futex_cmpxchg_enabled;
#endif
#define FUTEX_HASHBITS (CONFIG_BASE_SMALL ? 4 : 8)
/*
* Futex flags used to encode options to functions and preserve them across
* restarts.
*/
#define FLAGS_SHARED 0x01
#define FLAGS_CLOCKRT 0x02
#define FLAGS_HAS_TIMEOUT 0x04
/*
* Priority Inheritance state:
*/
struct futex_pi_state {
/*
* list of 'owned' pi_state instances - these have to be
* cleaned up in do_exit() if the task exits prematurely:
*/
struct list_head list;
/*
* The PI object:
*/
struct rt_mutex pi_mutex;
struct task_struct *owner;
atomic_t refcount;
union futex_key key;
};
/**
* struct futex_q - The hashed futex queue entry, one per waiting task
* @list: priority-sorted list of tasks waiting on this futex
* @task: the task waiting on the futex
* @lock_ptr: the hash bucket lock
* @key: the key the futex is hashed on
* @pi_state: optional priority inheritance state
* @rt_waiter: rt_waiter storage for use with requeue_pi
* @requeue_pi_key: the requeue_pi target futex key
* @bitset: bitset for the optional bitmasked wakeup
*
* We use this hashed waitqueue, instead of a normal wait_queue_t, so
* we can wake only the relevant ones (hashed queues may be shared).
*
* A futex_q has a woken state, just like tasks have TASK_RUNNING.
* It is considered woken when plist_node_empty(&q->list) || q->lock_ptr == 0.
* The order of wakeup is always to make the first condition true, then
* the second.
*
* PI futexes are typically woken before they are removed from the hash list via
* the rt_mutex code. See unqueue_me_pi().
*/
struct futex_q {
struct plist_node list;
struct task_struct *task;
spinlock_t *lock_ptr;
union futex_key key;
struct futex_pi_state *pi_state;
struct rt_mutex_waiter *rt_waiter;
union futex_key *requeue_pi_key;
u32 bitset;
};
static const struct futex_q futex_q_init = {
/* list gets initialized in queue_me()*/
.key = FUTEX_KEY_INIT,
.bitset = FUTEX_BITSET_MATCH_ANY
};
/*
* Hash buckets are shared by all the futex_keys that hash to the same
* location. Each key may have multiple futex_q structures, one for each task
* waiting on a futex.
*/
struct futex_hash_bucket {
spinlock_t lock;
struct plist_head chain;
};
static struct futex_hash_bucket futex_queues[1<<FUTEX_HASHBITS];
/*
* We hash on the keys returned from get_futex_key (see below).
*/
static struct futex_hash_bucket *hash_futex(union futex_key *key)
{
u32 hash = jhash2((u32*)&key->both.word,
(sizeof(key->both.word)+sizeof(key->both.ptr))/4,
key->both.offset);
return &futex_queues[hash & ((1 << FUTEX_HASHBITS)-1)];
}
/*
* Return 1 if two futex_keys are equal, 0 otherwise.
*/
static inline int match_futex(union futex_key *key1, union futex_key *key2)
{
return (key1 && key2
&& key1->both.word == key2->both.word
&& key1->both.ptr == key2->both.ptr
&& key1->both.offset == key2->both.offset);
}
/*
* Take a reference to the resource addressed by a key.
* Can be called while holding spinlocks.
*
*/
static void get_futex_key_refs(union futex_key *key)
{
if (!key->both.ptr)
return;
switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
case FUT_OFF_INODE:
ihold(key->shared.inode);
break;
case FUT_OFF_MMSHARED:
atomic_inc(&key->private.mm->mm_count);
break;
}
}
/*
* Drop a reference to the resource addressed by a key.
* The hash bucket spinlock must not be held.
*/
static void drop_futex_key_refs(union futex_key *key)
{
if (!key->both.ptr) {
/* If we're here then we tried to put a key we failed to get */
WARN_ON_ONCE(1);
return;
}
switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
case FUT_OFF_INODE:
iput(key->shared.inode);
break;
case FUT_OFF_MMSHARED:
mmdrop(key->private.mm);
break;
}
}
/**
* get_futex_key() - Get parameters which are the keys for a futex
* @uaddr: virtual address of the futex
* @fshared: 0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED
* @key: address where result is stored.
* @rw: mapping needs to be read/write (values: VERIFY_READ,
* VERIFY_WRITE)
*
* Return: a negative error code or 0
*
* The key words are stored in *key on success.
*
* For shared mappings, it's (page->index, file_inode(vma->vm_file),
* offset_within_page). For private mappings, it's (uaddr, current->mm).
* We can usually work out the index without swapping in the page.
*
* lock_page() might sleep, the caller should not hold a spinlock.
*/
static int
get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key, int rw)
{
unsigned long address = (unsigned long)uaddr;
struct mm_struct *mm = current->mm;
struct page *page, *page_head;
int err, ro = 0;
/*
* The futex address must be "naturally" aligned.
*/
key->both.offset = address % PAGE_SIZE;
if (unlikely((address % sizeof(u32)) != 0))
return -EINVAL;
address -= key->both.offset;
/*
* PROCESS_PRIVATE futexes are fast.
* As the mm cannot disappear under us and the 'key' only needs
* virtual address, we dont even have to find the underlying vma.
* Note : We do have to check 'uaddr' is a valid user address,
* but access_ok() should be faster than find_vma()
*/
if (!fshared) {
if (unlikely(!access_ok(VERIFY_WRITE, uaddr, sizeof(u32))))
return -EFAULT;
key->private.mm = mm;
key->private.address = address;
get_futex_key_refs(key);
return 0;
}
again:
err = get_user_pages_fast(address, 1, 1, &page);
/*
* If write access is not required (eg. FUTEX_WAIT), try
* and get read-only access.
*/
if (err == -EFAULT && rw == VERIFY_READ) {
err = get_user_pages_fast(address, 1, 0, &page);
ro = 1;
}
if (err < 0)
return err;
else
err = 0;
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
page_head = page;
if (unlikely(PageTail(page))) {
put_page(page);
/* serialize against __split_huge_page_splitting() */
local_irq_disable();
if (likely(__get_user_pages_fast(address, 1, !ro, &page) == 1)) {
page_head = compound_head(page);
/*
* page_head is valid pointer but we must pin
* it before taking the PG_lock and/or
* PG_compound_lock. The moment we re-enable
* irqs __split_huge_page_splitting() can
* return and the head page can be freed from
* under us. We can't take the PG_lock and/or
* PG_compound_lock on a page that could be
* freed from under us.
*/
if (page != page_head) {
get_page(page_head);
put_page(page);
}
local_irq_enable();
} else {
local_irq_enable();
goto again;
}
}
#else
page_head = compound_head(page);
if (page != page_head) {
get_page(page_head);
put_page(page);
}
#endif
lock_page(page_head);
/*
* If page_head->mapping is NULL, then it cannot be a PageAnon
* page; but it might be the ZERO_PAGE or in the gate area or
* in a special mapping (all cases which we are happy to fail);
* or it may have been a good file page when get_user_pages_fast
* found it, but truncated or holepunched or subjected to
* invalidate_complete_page2 before we got the page lock (also
* cases which we are happy to fail). And we hold a reference,
* so refcount care in invalidate_complete_page's remove_mapping
* prevents drop_caches from setting mapping to NULL beneath us.
*
* The case we do have to guard against is when memory pressure made
* shmem_writepage move it from filecache to swapcache beneath us:
* an unlikely race, but we do need to retry for page_head->mapping.
*/
if (!page_head->mapping) {
int shmem_swizzled = PageSwapCache(page_head);
unlock_page(page_head);
put_page(page_head);
if (shmem_swizzled)
goto again;
return -EFAULT;
}
/*
* Private mappings are handled in a simple way.
*
* NOTE: When userspace waits on a MAP_SHARED mapping, even if
* it's a read-only handle, it's expected that futexes attach to
* the object not the particular process.
*/
if (PageAnon(page_head)) {
/*
* A RO anonymous page will never change and thus doesn't make
* sense for futex operations.
*/
if (ro) {
err = -EFAULT;
goto out;
}
key->both.offset |= FUT_OFF_MMSHARED; /* ref taken on mm */
key->private.mm = mm;
key->private.address = address;
} else {
key->both.offset |= FUT_OFF_INODE; /* inode-based key */
key->shared.inode = page_head->mapping->host;
key->shared.pgoff = basepage_index(page);
}
get_futex_key_refs(key);
out:
unlock_page(page_head);
put_page(page_head);
return err;
}
static inline void put_futex_key(union futex_key *key)
{
drop_futex_key_refs(key);
}
/**
* fault_in_user_writeable() - Fault in user address and verify RW access
* @uaddr: pointer to faulting user space address
*
* Slow path to fixup the fault we just took in the atomic write
* access to @uaddr.
*
* We have no generic implementation of a non-destructive write to the
* user address. We know that we faulted in the atomic pagefault
* disabled section so we can as well avoid the #PF overhead by
* calling get_user_pages() right away.
*/
static int fault_in_user_writeable(u32 __user *uaddr)
{
struct mm_struct *mm = current->mm;
int ret;
down_read(&mm->mmap_sem);
ret = fixup_user_fault(current, mm, (unsigned long)uaddr,
FAULT_FLAG_WRITE);
up_read(&mm->mmap_sem);
return ret < 0 ? ret : 0;
}
/**
* futex_top_waiter() - Return the highest priority waiter on a futex
* @hb: the hash bucket the futex_q's reside in
* @key: the futex key (to distinguish it from other futex futex_q's)
*
* Must be called with the hb lock held.
*/
static struct futex_q *futex_top_waiter(struct futex_hash_bucket *hb,
union futex_key *key)
{
struct futex_q *this;
plist_for_each_entry(this, &hb->chain, list) {
if (match_futex(&this->key, key))
return this;
}
return NULL;
}
static int cmpxchg_futex_value_locked(u32 *curval, u32 __user *uaddr,
u32 uval, u32 newval)
{
int ret;
pagefault_disable();
ret = futex_atomic_cmpxchg_inatomic(curval, uaddr, uval, newval);
pagefault_enable();
return ret;
}
static int get_futex_value_locked(u32 *dest, u32 __user *from)
{
int ret;
pagefault_disable();
ret = __copy_from_user_inatomic(dest, from, sizeof(u32));
pagefault_enable();
return ret ? -EFAULT : 0;
}
/*
* PI code:
*/
static int refill_pi_state_cache(void)
{
struct futex_pi_state *pi_state;
if (likely(current->pi_state_cache))
return 0;
pi_state = kzalloc(sizeof(*pi_state), GFP_KERNEL);
if (!pi_state)
return -ENOMEM;
INIT_LIST_HEAD(&pi_state->list);
/* pi_mutex gets initialized later */
pi_state->owner = NULL;
atomic_set(&pi_state->refcount, 1);
pi_state->key = FUTEX_KEY_INIT;
current->pi_state_cache = pi_state;
return 0;
}
static struct futex_pi_state * alloc_pi_state(void)
{
struct futex_pi_state *pi_state = current->pi_state_cache;
WARN_ON(!pi_state);
current->pi_state_cache = NULL;
return pi_state;
}
static void free_pi_state(struct futex_pi_state *pi_state)
{
if (!atomic_dec_and_test(&pi_state->refcount))
return;
/*
* If pi_state->owner is NULL, the owner is most probably dying
* and has cleaned up the pi_state already
*/
if (pi_state->owner) {
raw_spin_lock_irq(&pi_state->owner->pi_lock);
list_del_init(&pi_state->list);
raw_spin_unlock_irq(&pi_state->owner->pi_lock);
rt_mutex_proxy_unlock(&pi_state->pi_mutex, pi_state->owner);
}
if (current->pi_state_cache)
kfree(pi_state);
else {
/*
* pi_state->list is already empty.
* clear pi_state->owner.
* refcount is at 0 - put it back to 1.
*/
pi_state->owner = NULL;
atomic_set(&pi_state->refcount, 1);
current->pi_state_cache = pi_state;
}
}
/*
* Look up the task based on what TID userspace gave us.
* We dont trust it.
*/
static struct task_struct * futex_find_get_task(pid_t pid)
{
struct task_struct *p;
rcu_read_lock();
p = find_task_by_vpid(pid);
if (p)
get_task_struct(p);
rcu_read_unlock();
return p;
}
/*
* This task is holding PI mutexes at exit time => bad.
* Kernel cleans up PI-state, but userspace is likely hosed.
* (Robust-futex cleanup is separate and might save the day for userspace.)
*/
void exit_pi_state_list(struct task_struct *curr)
{
struct list_head *next, *head = &curr->pi_state_list;
struct futex_pi_state *pi_state;
struct futex_hash_bucket *hb;
union futex_key key = FUTEX_KEY_INIT;
if (!futex_cmpxchg_enabled)
return;
/*
* We are a ZOMBIE and nobody can enqueue itself on
* pi_state_list anymore, but we have to be careful
* versus waiters unqueueing themselves:
*/
raw_spin_lock_irq(&curr->pi_lock);
while (!list_empty(head)) {
next = head->next;
pi_state = list_entry(next, struct futex_pi_state, list);
key = pi_state->key;
hb = hash_futex(&key);
raw_spin_unlock_irq(&curr->pi_lock);
spin_lock(&hb->lock);
raw_spin_lock_irq(&curr->pi_lock);
/*
* We dropped the pi-lock, so re-check whether this
* task still owns the PI-state:
*/
if (head->next != next) {
spin_unlock(&hb->lock);
continue;
}
WARN_ON(pi_state->owner != curr);
WARN_ON(list_empty(&pi_state->list));
list_del_init(&pi_state->list);
pi_state->owner = NULL;
raw_spin_unlock_irq(&curr->pi_lock);
rt_mutex_unlock(&pi_state->pi_mutex);
spin_unlock(&hb->lock);
raw_spin_lock_irq(&curr->pi_lock);
}
raw_spin_unlock_irq(&curr->pi_lock);
}
/*
* We need to check the following states:
*
* Waiter | pi_state | pi->owner | uTID | uODIED | ?
*
* [1] NULL | --- | --- | 0 | 0/1 | Valid
* [2] NULL | --- | --- | >0 | 0/1 | Valid
*
* [3] Found | NULL | -- | Any | 0/1 | Invalid
*
* [4] Found | Found | NULL | 0 | 1 | Valid
* [5] Found | Found | NULL | >0 | 1 | Invalid
*
* [6] Found | Found | task | 0 | 1 | Valid
*
* [7] Found | Found | NULL | Any | 0 | Invalid
*
* [8] Found | Found | task | ==taskTID | 0/1 | Valid
* [9] Found | Found | task | 0 | 0 | Invalid
* [10] Found | Found | task | !=taskTID | 0/1 | Invalid
*
* [1] Indicates that the kernel can acquire the futex atomically. We
* came came here due to a stale FUTEX_WAITERS/FUTEX_OWNER_DIED bit.
*
* [2] Valid, if TID does not belong to a kernel thread. If no matching
* thread is found then it indicates that the owner TID has died.
*
* [3] Invalid. The waiter is queued on a non PI futex
*
* [4] Valid state after exit_robust_list(), which sets the user space
* value to FUTEX_WAITERS | FUTEX_OWNER_DIED.
*
* [5] The user space value got manipulated between exit_robust_list()
* and exit_pi_state_list()
*
* [6] Valid state after exit_pi_state_list() which sets the new owner in
* the pi_state but cannot access the user space value.
*
* [7] pi_state->owner can only be NULL when the OWNER_DIED bit is set.
*
* [8] Owner and user space value match
*
* [9] There is no transient state which sets the user space TID to 0
* except exit_robust_list(), but this is indicated by the
* FUTEX_OWNER_DIED bit. See [4]
*
* [10] There is no transient state which leaves owner and user space
* TID out of sync.
*/
static int
lookup_pi_state(u32 uval, struct futex_hash_bucket *hb,
union futex_key *key, struct futex_pi_state **ps)
{
struct futex_pi_state *pi_state = NULL;
struct futex_q *this, *next;
struct plist_head *head;
struct task_struct *p;
pid_t pid = uval & FUTEX_TID_MASK;
head = &hb->chain;
plist_for_each_entry_safe(this, next, head, list) {
if (match_futex(&this->key, key)) {
/*
* Sanity check the waiter before increasing
* the refcount and attaching to it.
*/
pi_state = this->pi_state;
/*
* Userspace might have messed up non-PI and
* PI futexes [3]
*/
if (unlikely(!pi_state))
return -EINVAL;
WARN_ON(!atomic_read(&pi_state->refcount));
/*
* Handle the owner died case:
*/
if (uval & FUTEX_OWNER_DIED) {
/*
* exit_pi_state_list sets owner to NULL and
* wakes the topmost waiter. The task which
* acquires the pi_state->rt_mutex will fixup
* owner.
*/
if (!pi_state->owner) {
/*
* No pi state owner, but the user
* space TID is not 0. Inconsistent
* state. [5]
*/
if (pid)
return -EINVAL;
/*
* Take a ref on the state and
* return. [4]
*/
goto out_state;
}
/*
* If TID is 0, then either the dying owner
* has not yet executed exit_pi_state_list()
* or some waiter acquired the rtmutex in the
* pi state, but did not yet fixup the TID in
* user space.
*
* Take a ref on the state and return. [6]
*/
if (!pid)
goto out_state;
} else {
/*
* If the owner died bit is not set,
* then the pi_state must have an
* owner. [7]
*/
if (!pi_state->owner)
return -EINVAL;
}
/*
* Bail out if user space manipulated the
* futex value. If pi state exists then the
* owner TID must be the same as the user
* space TID. [9/10]
*/
if (pid != task_pid_vnr(pi_state->owner))
return -EINVAL;
out_state:
atomic_inc(&pi_state->refcount);
*ps = pi_state;
return 0;
}
}
/*
* We are the first waiter - try to look up the real owner and attach
* the new pi_state to it, but bail out when TID = 0 [1]
*/
if (!pid)
return -ESRCH;
p = futex_find_get_task(pid);
if (!p)
return -ESRCH;
if (!p->mm) {
put_task_struct(p);
return -EPERM;
}
/*
* We need to look at the task state flags to figure out,
* whether the task is exiting. To protect against the do_exit
* change of the task flags, we do this protected by
* p->pi_lock:
*/
raw_spin_lock_irq(&p->pi_lock);
if (unlikely(p->flags & PF_EXITING)) {
/*
* The task is on the way out. When PF_EXITPIDONE is
* set, we know that the task has finished the
* cleanup:
*/
int ret = (p->flags & PF_EXITPIDONE) ? -ESRCH : -EAGAIN;
raw_spin_unlock_irq(&p->pi_lock);
put_task_struct(p);
return ret;
}
/*
* No existing pi state. First waiter. [2]
*/
pi_state = alloc_pi_state();
/*
* Initialize the pi_mutex in locked state and make 'p'
* the owner of it:
*/
rt_mutex_init_proxy_locked(&pi_state->pi_mutex, p);
/* Store the key for possible exit cleanups: */
pi_state->key = *key;
WARN_ON(!list_empty(&pi_state->list));
list_add(&pi_state->list, &p->pi_state_list);
pi_state->owner = p;
raw_spin_unlock_irq(&p->pi_lock);
put_task_struct(p);
*ps = pi_state;
return 0;
}
/**
* futex_lock_pi_atomic() - Atomic work required to acquire a pi aware futex
* @uaddr: the pi futex user address
* @hb: the pi futex hash bucket
* @key: the futex key associated with uaddr and hb
* @ps: the pi_state pointer where we store the result of the
* lookup
* @task: the task to perform the atomic lock work for. This will
* be "current" except in the case of requeue pi.
* @set_waiters: force setting the FUTEX_WAITERS bit (1) or not (0)
*
* Return:
* 0 - ready to wait;
* 1 - acquired the lock;
* <0 - error
*
* The hb->lock and futex_key refs shall be held by the caller.
*/
static int futex_lock_pi_atomic(u32 __user *uaddr, struct futex_hash_bucket *hb,
union futex_key *key,
struct futex_pi_state **ps,
struct task_struct *task, int set_waiters)
{
int lock_taken, ret, force_take = 0;
u32 uval, newval, curval, vpid = task_pid_vnr(task);
retry:
ret = lock_taken = 0;
/*
* To avoid races, we attempt to take the lock here again
* (by doing a 0 -> TID atomic cmpxchg), while holding all
* the locks. It will most likely not succeed.
*/
newval = vpid;
if (set_waiters)
newval |= FUTEX_WAITERS;
if (unlikely(cmpxchg_futex_value_locked(&curval, uaddr, 0, newval)))
return -EFAULT;
/*
* Detect deadlocks.
*/
if ((unlikely((curval & FUTEX_TID_MASK) == vpid)))
return -EDEADLK;
/*
* Surprise - we got the lock, but we do not trust user space at all.
*/
if (unlikely(!curval)) {
/*
* We verify whether there is kernel state for this
* futex. If not, we can safely assume, that the 0 ->
* TID transition is correct. If state exists, we do
* not bother to fixup the user space state as it was
* corrupted already.
*/
return futex_top_waiter(hb, key) ? -EINVAL : 1;
}
uval = curval;
/*
* Set the FUTEX_WAITERS flag, so the owner will know it has someone
* to wake at the next unlock.
*/
newval = curval | FUTEX_WAITERS;
/*
* Should we force take the futex? See below.
*/
if (unlikely(force_take)) {
/*
* Keep the OWNER_DIED and the WAITERS bit and set the
* new TID value.
*/
newval = (curval & ~FUTEX_TID_MASK) | vpid;
force_take = 0;
lock_taken = 1;
}
if (unlikely(cmpxchg_futex_value_locked(&curval, uaddr, uval, newval)))
return -EFAULT;
if (unlikely(curval != uval))
goto retry;
/*
* We took the lock due to forced take over.
*/
if (unlikely(lock_taken))
return 1;
/*
* We dont have the lock. Look up the PI state (or create it if
* we are the first waiter):
*/
ret = lookup_pi_state(uval, hb, key, ps);
if (unlikely(ret)) {
switch (ret) {
case -ESRCH:
/*
* We failed to find an owner for this
* futex. So we have no pi_state to block
* on. This can happen in two cases:
*
* 1) The owner died
* 2) A stale FUTEX_WAITERS bit
*
* Re-read the futex value.
*/
if (get_futex_value_locked(&curval, uaddr))
return -EFAULT;
/*
* If the owner died or we have a stale
* WAITERS bit the owner TID in the user space
* futex is 0.
*/
if (!(curval & FUTEX_TID_MASK)) {
force_take = 1;
goto retry;
}
default:
break;
}
}
return ret;
}
/**
* __unqueue_futex() - Remove the futex_q from its futex_hash_bucket
* @q: The futex_q to unqueue
*
* The q->lock_ptr must not be NULL and must be held by the caller.
*/
static void __unqueue_futex(struct futex_q *q)
{
struct futex_hash_bucket *hb;
if (WARN_ON_SMP(!q->lock_ptr || !spin_is_locked(q->lock_ptr))
|| WARN_ON(plist_node_empty(&q->list)))
return;
hb = container_of(q->lock_ptr, struct futex_hash_bucket, lock);
plist_del(&q->list, &hb->chain);
}
/*
* The hash bucket lock must be held when this is called.
* Afterwards, the futex_q must not be accessed.
*/
static void wake_futex(struct futex_q *q)
{
struct task_struct *p = q->task;
if (WARN(q->pi_state || q->rt_waiter, "refusing to wake PI futex\n"))
return;
/*
* We set q->lock_ptr = NULL _before_ we wake up the task. If
* a non-futex wake up happens on another CPU then the task
* might exit and p would dereference a non-existing task
* struct. Prevent this by holding a reference on p across the
* wake up.
*/
get_task_struct(p);
__unqueue_futex(q);
/*
* The waiting task can free the futex_q as soon as
* q->lock_ptr = NULL is written, without taking any locks. A
* memory barrier is required here to prevent the following
* store to lock_ptr from getting ahead of the plist_del.
*/
smp_wmb();
q->lock_ptr = NULL;
wake_up_state(p, TASK_NORMAL);
put_task_struct(p);
}
static int wake_futex_pi(u32 __user *uaddr, u32 uval, struct futex_q *this)
{
struct task_struct *new_owner;
struct futex_pi_state *pi_state = this->pi_state;
u32 uninitialized_var(curval), newval;
int ret = 0;
if (!pi_state)
return -EINVAL;
/*
* If current does not own the pi_state then the futex is
* inconsistent and user space fiddled with the futex value.
*/
if (pi_state->owner != current)
return -EINVAL;
raw_spin_lock(&pi_state->pi_mutex.wait_lock);
new_owner = rt_mutex_next_owner(&pi_state->pi_mutex);
/*
* It is possible that the next waiter (the one that brought
* this owner to the kernel) timed out and is no longer
* waiting on the lock.
*/
if (!new_owner)
new_owner = this->task;
/*
* We pass it to the next owner. The WAITERS bit is always
* kept enabled while there is PI state around. We cleanup the
* owner died bit, because we are the owner.
*/
newval = FUTEX_WAITERS | task_pid_vnr(new_owner);
if (cmpxchg_futex_value_locked(&curval, uaddr, uval, newval))
ret = -EFAULT;
else if (curval != uval)
ret = -EINVAL;
if (ret) {
raw_spin_unlock(&pi_state->pi_mutex.wait_lock);
return ret;
}
raw_spin_lock_irq(&pi_state->owner->pi_lock);
WARN_ON(list_empty(&pi_state->list));
list_del_init(&pi_state->list);
raw_spin_unlock_irq(&pi_state->owner->pi_lock);
raw_spin_lock_irq(&new_owner->pi_lock);
WARN_ON(!list_empty(&pi_state->list));
list_add(&pi_state->list, &new_owner->pi_state_list);
pi_state->owner = new_owner;
raw_spin_unlock_irq(&new_owner->pi_lock);
raw_spin_unlock(&pi_state->pi_mutex.wait_lock);
rt_mutex_unlock(&pi_state->pi_mutex);
return 0;
}
static int unlock_futex_pi(u32 __user *uaddr, u32 uval)
{
u32 uninitialized_var(oldval);
/*
* There is no waiter, so we unlock the futex. The owner died
* bit has not to be preserved here. We are the owner:
*/
if (cmpxchg_futex_value_locked(&oldval, uaddr, uval, 0))
return -EFAULT;
if (oldval != uval)
return -EAGAIN;
return 0;
}
/*
* Express the locking dependencies for lockdep:
*/
static inline void
double_lock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
{
if (hb1 <= hb2) {
spin_lock(&hb1->lock);
if (hb1 < hb2)
spin_lock_nested(&hb2->lock, SINGLE_DEPTH_NESTING);
} else { /* hb1 > hb2 */
spin_lock(&hb2->lock);
spin_lock_nested(&hb1->lock, SINGLE_DEPTH_NESTING);
}
}
static inline void
double_unlock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
{
spin_unlock(&hb1->lock);
if (hb1 != hb2)
spin_unlock(&hb2->lock);
}
/*
* Wake up waiters matching bitset queued on this futex (uaddr).
*/
static int
futex_wake(u32 __user *uaddr, unsigned int flags, int nr_wake, u32 bitset)
{
struct futex_hash_bucket *hb;
struct futex_q *this, *next;
struct plist_head *head;
union futex_key key = FUTEX_KEY_INIT;
int ret;
if (!bitset)
return -EINVAL;
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_READ);
if (unlikely(ret != 0))
goto out;
hb = hash_futex(&key);
spin_lock(&hb->lock);
head = &hb->chain;
plist_for_each_entry_safe(this, next, head, list) {
if (match_futex (&this->key, &key)) {
if (this->pi_state || this->rt_waiter) {
ret = -EINVAL;
break;
}
/* Check if one of the bits is set in both bitsets */
if (!(this->bitset & bitset))
continue;
wake_futex(this);
if (++ret >= nr_wake)
break;
}
}
spin_unlock(&hb->lock);
put_futex_key(&key);
out:
return ret;
}
/*
* Wake up all waiters hashed on the physical page that is mapped
* to this virtual address:
*/
static int
futex_wake_op(u32 __user *uaddr1, unsigned int flags, u32 __user *uaddr2,
int nr_wake, int nr_wake2, int op)
{
union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
struct futex_hash_bucket *hb1, *hb2;
struct plist_head *head;
struct futex_q *this, *next;
int ret, op_ret;
retry:
ret = get_futex_key(uaddr1, flags & FLAGS_SHARED, &key1, VERIFY_READ);
if (unlikely(ret != 0))
goto out;
ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out_put_key1;
hb1 = hash_futex(&key1);
hb2 = hash_futex(&key2);
retry_private:
double_lock_hb(hb1, hb2);
op_ret = futex_atomic_op_inuser(op, uaddr2);
if (unlikely(op_ret < 0)) {
double_unlock_hb(hb1, hb2);
#ifndef CONFIG_MMU
/*
* we don't get EFAULT from MMU faults if we don't have an MMU,
* but we might get them from range checking
*/
ret = op_ret;
goto out_put_keys;
#endif
if (unlikely(op_ret != -EFAULT)) {
ret = op_ret;
goto out_put_keys;
}
ret = fault_in_user_writeable(uaddr2);
if (ret)
goto out_put_keys;
if (!(flags & FLAGS_SHARED))
goto retry_private;
put_futex_key(&key2);
put_futex_key(&key1);
goto retry;
}
head = &hb1->chain;
plist_for_each_entry_safe(this, next, head, list) {
if (match_futex (&this->key, &key1)) {
if (this->pi_state || this->rt_waiter) {
ret = -EINVAL;
goto out_unlock;
}
wake_futex(this);
if (++ret >= nr_wake)
break;
}
}
if (op_ret > 0) {
head = &hb2->chain;
op_ret = 0;
plist_for_each_entry_safe(this, next, head, list) {
if (match_futex (&this->key, &key2)) {
if (this->pi_state || this->rt_waiter) {
ret = -EINVAL;
goto out_unlock;
}
wake_futex(this);
if (++op_ret >= nr_wake2)
break;
}
}
ret += op_ret;
}
out_unlock:
double_unlock_hb(hb1, hb2);
out_put_keys:
put_futex_key(&key2);
out_put_key1:
put_futex_key(&key1);
out:
return ret;
}
/**
* requeue_futex() - Requeue a futex_q from one hb to another
* @q: the futex_q to requeue
* @hb1: the source hash_bucket
* @hb2: the target hash_bucket
* @key2: the new key for the requeued futex_q
*/
static inline
void requeue_futex(struct futex_q *q, struct futex_hash_bucket *hb1,
struct futex_hash_bucket *hb2, union futex_key *key2)
{
/*
* If key1 and key2 hash to the same bucket, no need to
* requeue.
*/
if (likely(&hb1->chain != &hb2->chain)) {
plist_del(&q->list, &hb1->chain);
plist_add(&q->list, &hb2->chain);
q->lock_ptr = &hb2->lock;
}
get_futex_key_refs(key2);
q->key = *key2;
}
/**
* requeue_pi_wake_futex() - Wake a task that acquired the lock during requeue
* @q: the futex_q
* @key: the key of the requeue target futex
* @hb: the hash_bucket of the requeue target futex
*
* During futex_requeue, with requeue_pi=1, it is possible to acquire the
* target futex if it is uncontended or via a lock steal. Set the futex_q key
* to the requeue target futex so the waiter can detect the wakeup on the right
* futex, but remove it from the hb and NULL the rt_waiter so it can detect
* atomic lock acquisition. Set the q->lock_ptr to the requeue target hb->lock
* to protect access to the pi_state to fixup the owner later. Must be called
* with both q->lock_ptr and hb->lock held.
*/
static inline
void requeue_pi_wake_futex(struct futex_q *q, union futex_key *key,
struct futex_hash_bucket *hb)
{
get_futex_key_refs(key);
q->key = *key;
__unqueue_futex(q);
WARN_ON(!q->rt_waiter);
q->rt_waiter = NULL;
q->lock_ptr = &hb->lock;
wake_up_state(q->task, TASK_NORMAL);
}
/**
* futex_proxy_trylock_atomic() - Attempt an atomic lock for the top waiter
* @pifutex: the user address of the to futex
* @hb1: the from futex hash bucket, must be locked by the caller
* @hb2: the to futex hash bucket, must be locked by the caller
* @key1: the from futex key
* @key2: the to futex key
* @ps: address to store the pi_state pointer
* @set_waiters: force setting the FUTEX_WAITERS bit (1) or not (0)
*
* Try and get the lock on behalf of the top waiter if we can do it atomically.
* Wake the top waiter if we succeed. If the caller specified set_waiters,
* then direct futex_lock_pi_atomic() to force setting the FUTEX_WAITERS bit.
* hb1 and hb2 must be held by the caller.
*
* Return:
* 0 - failed to acquire the lock atomically;
* >0 - acquired the lock, return value is vpid of the top_waiter
* <0 - error
*/
static int futex_proxy_trylock_atomic(u32 __user *pifutex,
struct futex_hash_bucket *hb1,
struct futex_hash_bucket *hb2,
union futex_key *key1, union futex_key *key2,
struct futex_pi_state **ps, int set_waiters)
{
struct futex_q *top_waiter = NULL;
u32 curval;
int ret, vpid;
if (get_futex_value_locked(&curval, pifutex))
return -EFAULT;
/*
* Find the top_waiter and determine if there are additional waiters.
* If the caller intends to requeue more than 1 waiter to pifutex,
* force futex_lock_pi_atomic() to set the FUTEX_WAITERS bit now,
* as we have means to handle the possible fault. If not, don't set
* the bit unecessarily as it will force the subsequent unlock to enter
* the kernel.
*/
top_waiter = futex_top_waiter(hb1, key1);
/* There are no waiters, nothing for us to do. */
if (!top_waiter)
return 0;
/* Ensure we requeue to the expected futex. */
if (!match_futex(top_waiter->requeue_pi_key, key2))
return -EINVAL;
/*
* Try to take the lock for top_waiter. Set the FUTEX_WAITERS bit in
* the contended case or if set_waiters is 1. The pi_state is returned
* in ps in contended cases.
*/
vpid = task_pid_vnr(top_waiter->task);
ret = futex_lock_pi_atomic(pifutex, hb2, key2, ps, top_waiter->task,
set_waiters);
if (ret == 1) {
requeue_pi_wake_futex(top_waiter, key2, hb2);
return vpid;
}
return ret;
}
/**
* futex_requeue() - Requeue waiters from uaddr1 to uaddr2
* @uaddr1: source futex user address
* @flags: futex flags (FLAGS_SHARED, etc.)
* @uaddr2: target futex user address
* @nr_wake: number of waiters to wake (must be 1 for requeue_pi)
* @nr_requeue: number of waiters to requeue (0-INT_MAX)
* @cmpval: @uaddr1 expected value (or %NULL)
* @requeue_pi: if we are attempting to requeue from a non-pi futex to a
* pi futex (pi to pi requeue is not supported)
*
* Requeue waiters on uaddr1 to uaddr2. In the requeue_pi case, try to acquire
* uaddr2 atomically on behalf of the top waiter.
*
* Return:
* >=0 - on success, the number of tasks requeued or woken;
* <0 - on error
*/
static int futex_requeue(u32 __user *uaddr1, unsigned int flags,
u32 __user *uaddr2, int nr_wake, int nr_requeue,
u32 *cmpval, int requeue_pi)
{
union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
int drop_count = 0, task_count = 0, ret;
struct futex_pi_state *pi_state = NULL;
struct futex_hash_bucket *hb1, *hb2;
struct plist_head *head1;
struct futex_q *this, *next;
u32 curval2;
if (requeue_pi) {
/*
* Requeue PI only works on two distinct uaddrs. This
* check is only valid for private futexes. See below.
*/
if (uaddr1 == uaddr2)
return -EINVAL;
/*
* requeue_pi requires a pi_state, try to allocate it now
* without any locks in case it fails.
*/
if (refill_pi_state_cache())
return -ENOMEM;
/*
* requeue_pi must wake as many tasks as it can, up to nr_wake
* + nr_requeue, since it acquires the rt_mutex prior to
* returning to userspace, so as to not leave the rt_mutex with
* waiters and no owner. However, second and third wake-ups
* cannot be predicted as they involve race conditions with the
* first wake and a fault while looking up the pi_state. Both
* pthread_cond_signal() and pthread_cond_broadcast() should
* use nr_wake=1.
*/
if (nr_wake != 1)
return -EINVAL;
}
retry:
if (pi_state != NULL) {
/*
* We will have to lookup the pi_state again, so free this one
* to keep the accounting correct.
*/
free_pi_state(pi_state);
pi_state = NULL;
}
ret = get_futex_key(uaddr1, flags & FLAGS_SHARED, &key1, VERIFY_READ);
if (unlikely(ret != 0))
goto out;
ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2,
requeue_pi ? VERIFY_WRITE : VERIFY_READ);
if (unlikely(ret != 0))
goto out_put_key1;
/*
* The check above which compares uaddrs is not sufficient for
* shared futexes. We need to compare the keys:
*/
if (requeue_pi && match_futex(&key1, &key2)) {
ret = -EINVAL;
goto out_put_keys;
}
/*
* The check above which compares uaddrs is not sufficient for
* shared futexes. We need to compare the keys:
*/
if (requeue_pi && match_futex(&key1, &key2)) {
ret = -EINVAL;
goto out_put_keys;
}
hb1 = hash_futex(&key1);
hb2 = hash_futex(&key2);
retry_private:
double_lock_hb(hb1, hb2);
if (likely(cmpval != NULL)) {
u32 curval;
ret = get_futex_value_locked(&curval, uaddr1);
if (unlikely(ret)) {
double_unlock_hb(hb1, hb2);
ret = get_user(curval, uaddr1);
if (ret)
goto out_put_keys;
if (!(flags & FLAGS_SHARED))
goto retry_private;
put_futex_key(&key2);
put_futex_key(&key1);
goto retry;
}
if (curval != *cmpval) {
ret = -EAGAIN;
goto out_unlock;
}
}
if (requeue_pi && (task_count - nr_wake < nr_requeue)) {
/*
* Attempt to acquire uaddr2 and wake the top waiter. If we
* intend to requeue waiters, force setting the FUTEX_WAITERS
* bit. We force this here where we are able to easily handle
* faults rather in the requeue loop below.
*/
ret = futex_proxy_trylock_atomic(uaddr2, hb1, hb2, &key1,
&key2, &pi_state, nr_requeue);
/*
* At this point the top_waiter has either taken uaddr2 or is
* waiting on it. If the former, then the pi_state will not
* exist yet, look it up one more time to ensure we have a
* reference to it. If the lock was taken, ret contains the
* vpid of the top waiter task.
*/
if (ret > 0) {
WARN_ON(pi_state);
drop_count++;
task_count++;
/*
* If we acquired the lock, then the user
* space value of uaddr2 should be vpid. It
* cannot be changed by the top waiter as it
* is blocked on hb2 lock if it tries to do
* so. If something fiddled with it behind our
* back the pi state lookup might unearth
* it. So we rather use the known value than
* rereading and handing potential crap to
* lookup_pi_state.
*/
ret = lookup_pi_state(ret, hb2, &key2, &pi_state);
}
switch (ret) {
case 0:
break;
case -EFAULT:
double_unlock_hb(hb1, hb2);
put_futex_key(&key2);
put_futex_key(&key1);
ret = fault_in_user_writeable(uaddr2);
if (!ret)
goto retry;
goto out;
case -EAGAIN:
/* The owner was exiting, try again. */
double_unlock_hb(hb1, hb2);
put_futex_key(&key2);
put_futex_key(&key1);
cond_resched();
goto retry;
default:
goto out_unlock;
}
}
head1 = &hb1->chain;
plist_for_each_entry_safe(this, next, head1, list) {
if (task_count - nr_wake >= nr_requeue)
break;
if (!match_futex(&this->key, &key1))
continue;
/*
* FUTEX_WAIT_REQEUE_PI and FUTEX_CMP_REQUEUE_PI should always
* be paired with each other and no other futex ops.
*
* We should never be requeueing a futex_q with a pi_state,
* which is awaiting a futex_unlock_pi().
*/
if ((requeue_pi && !this->rt_waiter) ||
(!requeue_pi && this->rt_waiter) ||
this->pi_state) {
ret = -EINVAL;
break;
}
/*
* Wake nr_wake waiters. For requeue_pi, if we acquired the
* lock, we already woke the top_waiter. If not, it will be
* woken by futex_unlock_pi().
*/
if (++task_count <= nr_wake && !requeue_pi) {
wake_futex(this);
continue;
}
/* Ensure we requeue to the expected futex for requeue_pi. */
if (requeue_pi && !match_futex(this->requeue_pi_key, &key2)) {
ret = -EINVAL;
break;
}
/*
* Requeue nr_requeue waiters and possibly one more in the case
* of requeue_pi if we couldn't acquire the lock atomically.
*/
if (requeue_pi) {
/* Prepare the waiter to take the rt_mutex. */
atomic_inc(&pi_state->refcount);
this->pi_state = pi_state;
ret = rt_mutex_start_proxy_lock(&pi_state->pi_mutex,
this->rt_waiter,
this->task, 1);
if (ret == 1) {
/* We got the lock. */
requeue_pi_wake_futex(this, &key2, hb2);
drop_count++;
continue;
} else if (ret) {
/* -EDEADLK */
this->pi_state = NULL;
free_pi_state(pi_state);
goto out_unlock;
}
}
requeue_futex(this, hb1, hb2, &key2);
drop_count++;
}
out_unlock:
double_unlock_hb(hb1, hb2);
/*
* drop_futex_key_refs() must be called outside the spinlocks. During
* the requeue we moved futex_q's from the hash bucket at key1 to the
* one at key2 and updated their key pointer. We no longer need to
* hold the references to key1.
*/
while (--drop_count >= 0)
drop_futex_key_refs(&key1);
out_put_keys:
put_futex_key(&key2);
out_put_key1:
put_futex_key(&key1);
out:
if (pi_state != NULL)
free_pi_state(pi_state);
return ret ? ret : task_count;
}
/* The key must be already stored in q->key. */
static inline struct futex_hash_bucket *queue_lock(struct futex_q *q)
__acquires(&hb->lock)
{
struct futex_hash_bucket *hb;
hb = hash_futex(&q->key);
q->lock_ptr = &hb->lock;
spin_lock(&hb->lock);
return hb;
}
static inline void
queue_unlock(struct futex_q *q, struct futex_hash_bucket *hb)
__releases(&hb->lock)
{
spin_unlock(&hb->lock);
}
/**
* queue_me() - Enqueue the futex_q on the futex_hash_bucket
* @q: The futex_q to enqueue
* @hb: The destination hash bucket
*
* The hb->lock must be held by the caller, and is released here. A call to
* queue_me() is typically paired with exactly one call to unqueue_me(). The
* exceptions involve the PI related operations, which may use unqueue_me_pi()
* or nothing if the unqueue is done as part of the wake process and the unqueue
* state is implicit in the state of woken task (see futex_wait_requeue_pi() for
* an example).
*/
static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
__releases(&hb->lock)
{
int prio;
/*
* The priority used to register this element is
* - either the real thread-priority for the real-time threads
* (i.e. threads with a priority lower than MAX_RT_PRIO)
* - or MAX_RT_PRIO for non-RT threads.
* Thus, all RT-threads are woken first in priority order, and
* the others are woken last, in FIFO order.
*/
prio = min(current->normal_prio, MAX_RT_PRIO);
plist_node_init(&q->list, prio);
plist_add(&q->list, &hb->chain);
q->task = current;
spin_unlock(&hb->lock);
}
/**
* unqueue_me() - Remove the futex_q from its futex_hash_bucket
* @q: The futex_q to unqueue
*
* The q->lock_ptr must not be held by the caller. A call to unqueue_me() must
* be paired with exactly one earlier call to queue_me().
*
* Return:
* 1 - if the futex_q was still queued (and we removed unqueued it);
* 0 - if the futex_q was already removed by the waking thread
*/
static int unqueue_me(struct futex_q *q)
{
spinlock_t *lock_ptr;
int ret = 0;
/* In the common case we don't take the spinlock, which is nice. */
retry:
lock_ptr = q->lock_ptr;
barrier();
if (lock_ptr != NULL) {
spin_lock(lock_ptr);
/*
* q->lock_ptr can change between reading it and
* spin_lock(), causing us to take the wrong lock. This
* corrects the race condition.
*
* Reasoning goes like this: if we have the wrong lock,
* q->lock_ptr must have changed (maybe several times)
* between reading it and the spin_lock(). It can
* change again after the spin_lock() but only if it was
* already changed before the spin_lock(). It cannot,
* however, change back to the original value. Therefore
* we can detect whether we acquired the correct lock.
*/
if (unlikely(lock_ptr != q->lock_ptr)) {
spin_unlock(lock_ptr);
goto retry;
}
__unqueue_futex(q);
BUG_ON(q->pi_state);
spin_unlock(lock_ptr);
ret = 1;
}
drop_futex_key_refs(&q->key);
return ret;
}
/*
* PI futexes can not be requeued and must remove themself from the
* hash bucket. The hash bucket lock (i.e. lock_ptr) is held on entry
* and dropped here.
*/
static void unqueue_me_pi(struct futex_q *q)
__releases(q->lock_ptr)
{
__unqueue_futex(q);
BUG_ON(!q->pi_state);
free_pi_state(q->pi_state);
q->pi_state = NULL;
spin_unlock(q->lock_ptr);
}
/*
* Fixup the pi_state owner with the new owner.
*
* Must be called with hash bucket lock held and mm->sem held for non
* private futexes.
*/
static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
struct task_struct *newowner)
{
u32 newtid = task_pid_vnr(newowner) | FUTEX_WAITERS;
struct futex_pi_state *pi_state = q->pi_state;
struct task_struct *oldowner = pi_state->owner;
u32 uval, uninitialized_var(curval), newval;
int ret;
/* Owner died? */
if (!pi_state->owner)
newtid |= FUTEX_OWNER_DIED;
/*
* We are here either because we stole the rtmutex from the
* previous highest priority waiter or we are the highest priority
* waiter but failed to get the rtmutex the first time.
* We have to replace the newowner TID in the user space variable.
* This must be atomic as we have to preserve the owner died bit here.
*
* Note: We write the user space value _before_ changing the pi_state
* because we can fault here. Imagine swapped out pages or a fork
* that marked all the anonymous memory readonly for cow.
*
* Modifying pi_state _before_ the user space value would
* leave the pi_state in an inconsistent state when we fault
* here, because we need to drop the hash bucket lock to
* handle the fault. This might be observed in the PID check
* in lookup_pi_state.
*/
retry:
if (get_futex_value_locked(&uval, uaddr))
goto handle_fault;
while (1) {
newval = (uval & FUTEX_OWNER_DIED) | newtid;
if (cmpxchg_futex_value_locked(&curval, uaddr, uval, newval))
goto handle_fault;
if (curval == uval)
break;
uval = curval;
}
/*
* We fixed up user space. Now we need to fix the pi_state
* itself.
*/
if (pi_state->owner != NULL) {
raw_spin_lock_irq(&pi_state->owner->pi_lock);
WARN_ON(list_empty(&pi_state->list));
list_del_init(&pi_state->list);
raw_spin_unlock_irq(&pi_state->owner->pi_lock);
}
pi_state->owner = newowner;
raw_spin_lock_irq(&newowner->pi_lock);
WARN_ON(!list_empty(&pi_state->list));
list_add(&pi_state->list, &newowner->pi_state_list);
raw_spin_unlock_irq(&newowner->pi_lock);
return 0;
/*
* To handle the page fault we need to drop the hash bucket
* lock here. That gives the other task (either the highest priority
* waiter itself or the task which stole the rtmutex) the
* chance to try the fixup of the pi_state. So once we are
* back from handling the fault we need to check the pi_state
* after reacquiring the hash bucket lock and before trying to
* do another fixup. When the fixup has been done already we
* simply return.
*/
handle_fault:
spin_unlock(q->lock_ptr);
ret = fault_in_user_writeable(uaddr);
spin_lock(q->lock_ptr);
/*
* Check if someone else fixed it for us:
*/
if (pi_state->owner != oldowner)
return 0;
if (ret)
return ret;
goto retry;
}
static long futex_wait_restart(struct restart_block *restart);
/**
* fixup_owner() - Post lock pi_state and corner case management
* @uaddr: user address of the futex
* @q: futex_q (contains pi_state and access to the rt_mutex)
* @locked: if the attempt to take the rt_mutex succeeded (1) or not (0)
*
* After attempting to lock an rt_mutex, this function is called to cleanup
* the pi_state owner as well as handle race conditions that may allow us to
* acquire the lock. Must be called with the hb lock held.
*
* Return:
* 1 - success, lock taken;
* 0 - success, lock not taken;
* <0 - on error (-EFAULT)
*/
static int fixup_owner(u32 __user *uaddr, struct futex_q *q, int locked)
{
struct task_struct *owner;
int ret = 0;
if (locked) {
/*
* Got the lock. We might not be the anticipated owner if we
* did a lock-steal - fix up the PI-state in that case:
*/
if (q->pi_state->owner != current)
ret = fixup_pi_state_owner(uaddr, q, current);
goto out;
}
/*
* Catch the rare case, where the lock was released when we were on the
* way back before we locked the hash bucket.
*/
if (q->pi_state->owner == current) {
/*
* Try to get the rt_mutex now. This might fail as some other
* task acquired the rt_mutex after we removed ourself from the
* rt_mutex waiters list.
*/
if (rt_mutex_trylock(&q->pi_state->pi_mutex)) {
locked = 1;
goto out;
}
/*
* pi_state is incorrect, some other task did a lock steal and
* we returned due to timeout or signal without taking the
* rt_mutex. Too late.
*/
raw_spin_lock(&q->pi_state->pi_mutex.wait_lock);
owner = rt_mutex_owner(&q->pi_state->pi_mutex);
if (!owner)
owner = rt_mutex_next_owner(&q->pi_state->pi_mutex);
raw_spin_unlock(&q->pi_state->pi_mutex.wait_lock);
ret = fixup_pi_state_owner(uaddr, q, owner);
goto out;
}
/*
* Paranoia check. If we did not take the lock, then we should not be
* the owner of the rt_mutex.
*/
if (rt_mutex_owner(&q->pi_state->pi_mutex) == current)
printk(KERN_ERR "fixup_owner: ret = %d pi-mutex: %p "
"pi-state %p\n", ret,
q->pi_state->pi_mutex.owner,
q->pi_state->owner);
out:
return ret ? ret : locked;
}
/**
* futex_wait_queue_me() - queue_me() and wait for wakeup, timeout, or signal
* @hb: the futex hash bucket, must be locked by the caller
* @q: the futex_q to queue up on
* @timeout: the prepared hrtimer_sleeper, or null for no timeout
*/
static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
struct hrtimer_sleeper *timeout)
{
/*
* The task state is guaranteed to be set before another task can
* wake it. set_current_state() is implemented using set_mb() and
* queue_me() calls spin_unlock() upon completion, both serializing
* access to the hash list and forcing another memory barrier.
*/
set_current_state(TASK_INTERRUPTIBLE);
queue_me(q, hb);
/* Arm the timer */
if (timeout) {
hrtimer_start_expires(&timeout->timer, HRTIMER_MODE_ABS);
if (!hrtimer_active(&timeout->timer))
timeout->task = NULL;
}
/*
* If we have been removed from the hash list, then another task
* has tried to wake us, and we can skip the call to schedule().
*/
if (likely(!plist_node_empty(&q->list))) {
/*
* If the timer has already expired, current will already be
* flagged for rescheduling. Only call schedule if there
* is no timeout, or if it has yet to expire.
*/
if (!timeout || timeout->task)
freezable_schedule();
}
__set_current_state(TASK_RUNNING);
}
/**
* futex_wait_setup() - Prepare to wait on a futex
* @uaddr: the futex userspace address
* @val: the expected value
* @flags: futex flags (FLAGS_SHARED, etc.)
* @q: the associated futex_q
* @hb: storage for hash_bucket pointer to be returned to caller
*
* Setup the futex_q and locate the hash_bucket. Get the futex value and
* compare it with the expected value. Handle atomic faults internally.
* Return with the hb lock held and a q.key reference on success, and unlocked
* with no q.key reference on failure.
*
* Return:
* 0 - uaddr contains val and hb has been locked;
* <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlocked
*/
static int futex_wait_setup(u32 __user *uaddr, u32 val, unsigned int flags,
struct futex_q *q, struct futex_hash_bucket **hb)
{
u32 uval;
int ret;
/*
* Access the page AFTER the hash-bucket is locked.
* Order is important:
*
* Userspace waiter: val = var; if (cond(val)) futex_wait(&var, val);
* Userspace waker: if (cond(var)) { var = new; futex_wake(&var); }
*
* The basic logical guarantee of a futex is that it blocks ONLY
* if cond(var) is known to be true at the time of blocking, for
* any cond. If we locked the hash-bucket after testing *uaddr, that
* would open a race condition where we could block indefinitely with
* cond(var) false, which would violate the guarantee.
*
* On the other hand, we insert q and release the hash-bucket only
* after testing *uaddr. This guarantees that futex_wait() will NOT
* absorb a wakeup if *uaddr does not match the desired values
* while the syscall executes.
*/
retry:
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q->key, VERIFY_READ);
if (unlikely(ret != 0))
return ret;
retry_private:
*hb = queue_lock(q);
ret = get_futex_value_locked(&uval, uaddr);
if (ret) {
queue_unlock(q, *hb);
ret = get_user(uval, uaddr);
if (ret)
goto out;
if (!(flags & FLAGS_SHARED))
goto retry_private;
put_futex_key(&q->key);
goto retry;
}
if (uval != val) {
queue_unlock(q, *hb);
ret = -EWOULDBLOCK;
}
out:
if (ret)
put_futex_key(&q->key);
return ret;
}
static int futex_wait(u32 __user *uaddr, unsigned int flags, u32 val,
ktime_t *abs_time, u32 bitset)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct restart_block *restart;
struct futex_hash_bucket *hb;
struct futex_q q = futex_q_init;
int ret;
if (!bitset)
return -EINVAL;
q.bitset = bitset;
if (abs_time) {
to = &timeout;
hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?
CLOCK_REALTIME : CLOCK_MONOTONIC,
HRTIMER_MODE_ABS);
hrtimer_init_sleeper(to, current);
hrtimer_set_expires_range_ns(&to->timer, *abs_time,
current->timer_slack_ns);
}
retry:
/*
* Prepare to wait on uaddr. On success, holds hb lock and increments
* q.key refs.
*/
ret = futex_wait_setup(uaddr, val, flags, &q, &hb);
if (ret)
goto out;
/* queue_me and wait for wakeup, timeout, or a signal. */
futex_wait_queue_me(hb, &q, to);
/* If we were woken (and unqueued), we succeeded, whatever. */
ret = 0;
/* unqueue_me() drops q.key ref */
if (!unqueue_me(&q))
goto out;
ret = -ETIMEDOUT;
if (to && !to->task)
goto out;
/*
* We expect signal_pending(current), but we might be the
* victim of a spurious wakeup as well.
*/
if (!signal_pending(current))
goto retry;
ret = -ERESTARTSYS;
if (!abs_time)
goto out;
restart = ¤t_thread_info()->restart_block;
restart->fn = futex_wait_restart;
restart->futex.uaddr = uaddr;
restart->futex.val = val;
restart->futex.time = abs_time->tv64;
restart->futex.bitset = bitset;
restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;
ret = -ERESTART_RESTARTBLOCK;
out:
if (to) {
hrtimer_cancel(&to->timer);
destroy_hrtimer_on_stack(&to->timer);
}
return ret;
}
static long futex_wait_restart(struct restart_block *restart)
{
u32 __user *uaddr = restart->futex.uaddr;
ktime_t t, *tp = NULL;
if (restart->futex.flags & FLAGS_HAS_TIMEOUT) {
t.tv64 = restart->futex.time;
tp = &t;
}
restart->fn = do_no_restart_syscall;
return (long)futex_wait(uaddr, restart->futex.flags,
restart->futex.val, tp, restart->futex.bitset);
}
/*
* Userspace tried a 0 -> TID atomic transition of the futex value
* and failed. The kernel side here does the whole locking operation:
* if there are waiters then it will block, it does PI, etc. (Due to
* races the kernel might see a 0 value of the futex too.)
*/
static int futex_lock_pi(u32 __user *uaddr, unsigned int flags, int detect,
ktime_t *time, int trylock)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct futex_hash_bucket *hb;
struct futex_q q = futex_q_init;
int res, ret;
if (refill_pi_state_cache())
return -ENOMEM;
if (time) {
to = &timeout;
hrtimer_init_on_stack(&to->timer, CLOCK_REALTIME,
HRTIMER_MODE_ABS);
hrtimer_init_sleeper(to, current);
hrtimer_set_expires(&to->timer, *time);
}
retry:
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q.key, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out;
retry_private:
hb = queue_lock(&q);
ret = futex_lock_pi_atomic(uaddr, hb, &q.key, &q.pi_state, current, 0);
if (unlikely(ret)) {
switch (ret) {
case 1:
/* We got the lock. */
ret = 0;
goto out_unlock_put_key;
case -EFAULT:
goto uaddr_faulted;
case -EAGAIN:
/*
* Task is exiting and we just wait for the
* exit to complete.
*/
queue_unlock(&q, hb);
put_futex_key(&q.key);
cond_resched();
goto retry;
default:
goto out_unlock_put_key;
}
}
/*
* Only actually queue now that the atomic ops are done:
*/
queue_me(&q, hb);
WARN_ON(!q.pi_state);
/*
* Block on the PI mutex:
*/
if (!trylock)
ret = rt_mutex_timed_lock(&q.pi_state->pi_mutex, to, 1);
else {
ret = rt_mutex_trylock(&q.pi_state->pi_mutex);
/* Fixup the trylock return value: */
ret = ret ? 0 : -EWOULDBLOCK;
}
spin_lock(q.lock_ptr);
/*
* Fixup the pi_state owner and possibly acquire the lock if we
* haven't already.
*/
res = fixup_owner(uaddr, &q, !ret);
/*
* If fixup_owner() returned an error, proprogate that. If it acquired
* the lock, clear our -ETIMEDOUT or -EINTR.
*/
if (res)
ret = (res < 0) ? res : 0;
/*
* If fixup_owner() faulted and was unable to handle the fault, unlock
* it and return the fault to userspace.
*/
if (ret && (rt_mutex_owner(&q.pi_state->pi_mutex) == current))
rt_mutex_unlock(&q.pi_state->pi_mutex);
/* Unqueue and drop the lock */
unqueue_me_pi(&q);
goto out_put_key;
out_unlock_put_key:
queue_unlock(&q, hb);
out_put_key:
put_futex_key(&q.key);
out:
if (to)
destroy_hrtimer_on_stack(&to->timer);
return ret != -EINTR ? ret : -ERESTARTNOINTR;
uaddr_faulted:
queue_unlock(&q, hb);
ret = fault_in_user_writeable(uaddr);
if (ret)
goto out_put_key;
if (!(flags & FLAGS_SHARED))
goto retry_private;
put_futex_key(&q.key);
goto retry;
}
/*
* Userspace attempted a TID -> 0 atomic transition, and failed.
* This is the in-kernel slowpath: we look up the PI state (if any),
* and do the rt-mutex unlock.
*/
static int futex_unlock_pi(u32 __user *uaddr, unsigned int flags)
{
struct futex_hash_bucket *hb;
struct futex_q *this, *next;
struct plist_head *head;
union futex_key key = FUTEX_KEY_INIT;
u32 uval, vpid = task_pid_vnr(current);
int ret;
retry:
if (get_user(uval, uaddr))
return -EFAULT;
/*
* We release only a lock we actually own:
*/
if ((uval & FUTEX_TID_MASK) != vpid)
return -EPERM;
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out;
hb = hash_futex(&key);
spin_lock(&hb->lock);
/*
* To avoid races, try to do the TID -> 0 atomic transition
* again. If it succeeds then we can return without waking
* anyone else up. We only try this if neither the waiters nor
* the owner died bit are set.
*/
if (!(uval & ~FUTEX_TID_MASK) &&
cmpxchg_futex_value_locked(&uval, uaddr, vpid, 0))
goto pi_faulted;
/*
* Rare case: we managed to release the lock atomically,
* no need to wake anyone else up:
*/
if (unlikely(uval == vpid))
goto out_unlock;
/*
* Ok, other tasks may need to be woken up - check waiters
* and do the wakeup if necessary:
*/
head = &hb->chain;
plist_for_each_entry_safe(this, next, head, list) {
if (!match_futex (&this->key, &key))
continue;
ret = wake_futex_pi(uaddr, uval, this);
/*
* The atomic access to the futex value
* generated a pagefault, so retry the
* user-access and the wakeup:
*/
if (ret == -EFAULT)
goto pi_faulted;
goto out_unlock;
}
/*
* No waiters - kernel unlocks the futex:
*/
ret = unlock_futex_pi(uaddr, uval);
if (ret == -EFAULT)
goto pi_faulted;
out_unlock:
spin_unlock(&hb->lock);
put_futex_key(&key);
out:
return ret;
pi_faulted:
spin_unlock(&hb->lock);
put_futex_key(&key);
ret = fault_in_user_writeable(uaddr);
if (!ret)
goto retry;
return ret;
}
/**
* handle_early_requeue_pi_wakeup() - Detect early wakeup on the initial futex
* @hb: the hash_bucket futex_q was original enqueued on
* @q: the futex_q woken while waiting to be requeued
* @key2: the futex_key of the requeue target futex
* @timeout: the timeout associated with the wait (NULL if none)
*
* Detect if the task was woken on the initial futex as opposed to the requeue
* target futex. If so, determine if it was a timeout or a signal that caused
* the wakeup and return the appropriate error code to the caller. Must be
* called with the hb lock held.
*
* Return:
* 0 = no early wakeup detected;
* <0 = -ETIMEDOUT or -ERESTARTNOINTR
*/
static inline
int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
struct futex_q *q, union futex_key *key2,
struct hrtimer_sleeper *timeout)
{
int ret = 0;
/*
* With the hb lock held, we avoid races while we process the wakeup.
* We only need to hold hb (and not hb2) to ensure atomicity as the
* wakeup code can't change q.key from uaddr to uaddr2 if we hold hb.
* It can't be requeued from uaddr2 to something else since we don't
* support a PI aware source futex for requeue.
*/
if (!match_futex(&q->key, key2)) {
WARN_ON(q->lock_ptr && (&hb->lock != q->lock_ptr));
/*
* We were woken prior to requeue by a timeout or a signal.
* Unqueue the futex_q and determine which it was.
*/
plist_del(&q->list, &hb->chain);
/* Handle spurious wakeups gracefully */
ret = -EWOULDBLOCK;
if (timeout && !timeout->task)
ret = -ETIMEDOUT;
else if (signal_pending(current))
ret = -ERESTARTNOINTR;
}
return ret;
}
/**
* futex_wait_requeue_pi() - Wait on uaddr and take uaddr2
* @uaddr: the futex we initially wait on (non-pi)
* @flags: futex flags (FLAGS_SHARED, FLAGS_CLOCKRT, etc.), they must be
* the same type, no requeueing from private to shared, etc.
* @val: the expected value of uaddr
* @abs_time: absolute timeout
* @bitset: 32 bit wakeup bitset set by userspace, defaults to all
* @uaddr2: the pi futex we will take prior to returning to user-space
*
* The caller will wait on uaddr and will be requeued by futex_requeue() to
* uaddr2 which must be PI aware and unique from uaddr. Normal wakeup will wake
* on uaddr2 and complete the acquisition of the rt_mutex prior to returning to
* userspace. This ensures the rt_mutex maintains an owner when it has waiters;
* without one, the pi logic would not know which task to boost/deboost, if
* there was a need to.
*
* We call schedule in futex_wait_queue_me() when we enqueue and return there
* via the following--
* 1) wakeup on uaddr2 after an atomic lock acquisition by futex_requeue()
* 2) wakeup on uaddr2 after a requeue
* 3) signal
* 4) timeout
*
* If 3, cleanup and return -ERESTARTNOINTR.
*
* If 2, we may then block on trying to take the rt_mutex and return via:
* 5) successful lock
* 6) signal
* 7) timeout
* 8) other lock acquisition failure
*
* If 6, return -EWOULDBLOCK (restarting the syscall would do the same).
*
* If 4 or 7, we cleanup and return with -ETIMEDOUT.
*
* Return:
* 0 - On success;
* <0 - On error
*/
static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
u32 val, ktime_t *abs_time, u32 bitset,
u32 __user *uaddr2)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct rt_mutex_waiter rt_waiter;
struct rt_mutex *pi_mutex = NULL;
struct futex_hash_bucket *hb;
union futex_key key2 = FUTEX_KEY_INIT;
struct futex_q q = futex_q_init;
int res, ret;
if (uaddr == uaddr2)
return -EINVAL;
if (!bitset)
return -EINVAL;
if (abs_time) {
to = &timeout;
hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?
CLOCK_REALTIME : CLOCK_MONOTONIC,
HRTIMER_MODE_ABS);
hrtimer_init_sleeper(to, current);
hrtimer_set_expires_range_ns(&to->timer, *abs_time,
current->timer_slack_ns);
}
/*
* The waiter is allocated on our stack, manipulated by the requeue
* code while we sleep on uaddr.
*/
debug_rt_mutex_init_waiter(&rt_waiter);
rt_waiter.task = NULL;
ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out;
q.bitset = bitset;
q.rt_waiter = &rt_waiter;
q.requeue_pi_key = &key2;
/*
* Prepare to wait on uaddr. On success, increments q.key (key1) ref
* count.
*/
ret = futex_wait_setup(uaddr, val, flags, &q, &hb);
if (ret)
goto out_key2;
/*
* The check above which compares uaddrs is not sufficient for
* shared futexes. We need to compare the keys:
*/
if (match_futex(&q.key, &key2)) {
ret = -EINVAL;
goto out_put_keys;
}
/*
* The check above which compares uaddrs is not sufficient for
* shared futexes. We need to compare the keys:
*/
if (match_futex(&q.key, &key2)) {
ret = -EINVAL;
goto out_put_keys;
}
/* Queue the futex_q, drop the hb lock, wait for wakeup. */
futex_wait_queue_me(hb, &q, to);
spin_lock(&hb->lock);
ret = handle_early_requeue_pi_wakeup(hb, &q, &key2, to);
spin_unlock(&hb->lock);
if (ret)
goto out_put_keys;
/*
* In order for us to be here, we know our q.key == key2, and since
* we took the hb->lock above, we also know that futex_requeue() has
* completed and we no longer have to concern ourselves with a wakeup
* race with the atomic proxy lock acquisition by the requeue code. The
* futex_requeue dropped our key1 reference and incremented our key2
* reference count.
*/
/* Check if the requeue code acquired the second futex for us. */
if (!q.rt_waiter) {
/*
* Got the lock. We might not be the anticipated owner if we
* did a lock-steal - fix up the PI-state in that case.
*/
if (q.pi_state && (q.pi_state->owner != current)) {
spin_lock(q.lock_ptr);
ret = fixup_pi_state_owner(uaddr2, &q, current);
spin_unlock(q.lock_ptr);
}
} else {
/*
* We have been woken up by futex_unlock_pi(), a timeout, or a
* signal. futex_unlock_pi() will not destroy the lock_ptr nor
* the pi_state.
*/
WARN_ON(!q.pi_state);
pi_mutex = &q.pi_state->pi_mutex;
ret = rt_mutex_finish_proxy_lock(pi_mutex, to, &rt_waiter, 1);
debug_rt_mutex_free_waiter(&rt_waiter);
spin_lock(q.lock_ptr);
/*
* Fixup the pi_state owner and possibly acquire the lock if we
* haven't already.
*/
res = fixup_owner(uaddr2, &q, !ret);
/*
* If fixup_owner() returned an error, proprogate that. If it
* acquired the lock, clear -ETIMEDOUT or -EINTR.
*/
if (res)
ret = (res < 0) ? res : 0;
/* Unqueue and drop the lock. */
unqueue_me_pi(&q);
}
/*
* If fixup_pi_state_owner() faulted and was unable to handle the
* fault, unlock the rt_mutex and return the fault to userspace.
*/
if (ret == -EFAULT) {
if (pi_mutex && rt_mutex_owner(pi_mutex) == current)
rt_mutex_unlock(pi_mutex);
} else if (ret == -EINTR) {
/*
* We've already been requeued, but cannot restart by calling
* futex_lock_pi() directly. We could restart this syscall, but
* it would detect that the user space "val" changed and return
* -EWOULDBLOCK. Save the overhead of the restart and return
* -EWOULDBLOCK directly.
*/
ret = -EWOULDBLOCK;
}
out_put_keys:
put_futex_key(&q.key);
out_key2:
put_futex_key(&key2);
out:
if (to) {
hrtimer_cancel(&to->timer);
destroy_hrtimer_on_stack(&to->timer);
}
return ret;
}
/*
* Support for robust futexes: the kernel cleans up held futexes at
* thread exit time.
*
* Implementation: user-space maintains a per-thread list of locks it
* is holding. Upon do_exit(), the kernel carefully walks this list,
* and marks all locks that are owned by this thread with the
* FUTEX_OWNER_DIED bit, and wakes up a waiter (if any). The list is
* always manipulated with the lock held, so the list is private and
* per-thread. Userspace also maintains a per-thread 'list_op_pending'
* field, to allow the kernel to clean up if the thread dies after
* acquiring the lock, but just before it could have added itself to
* the list. There can only be one such pending lock.
*/
/**
* sys_set_robust_list() - Set the robust-futex list head of a task
* @head: pointer to the list-head
* @len: length of the list-head, as userspace expects
*/
SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
size_t, len)
{
if (!futex_cmpxchg_enabled)
return -ENOSYS;
/*
* The kernel knows only one size for now:
*/
if (unlikely(len != sizeof(*head)))
return -EINVAL;
current->robust_list = head;
return 0;
}
/**
* sys_get_robust_list() - Get the robust-futex list head of a task
* @pid: pid of the process [zero for current task]
* @head_ptr: pointer to a list-head pointer, the kernel fills it in
* @len_ptr: pointer to a length field, the kernel fills in the header size
*/
SYSCALL_DEFINE3(get_robust_list, int, pid,
struct robust_list_head __user * __user *, head_ptr,
size_t __user *, len_ptr)
{
struct robust_list_head __user *head;
unsigned long ret;
struct task_struct *p;
if (!futex_cmpxchg_enabled)
return -ENOSYS;
rcu_read_lock();
ret = -ESRCH;
if (!pid)
p = current;
else {
p = find_task_by_vpid(pid);
if (!p)
goto err_unlock;
}
ret = -EPERM;
if (!ptrace_may_access(p, PTRACE_MODE_READ))
goto err_unlock;
head = p->robust_list;
rcu_read_unlock();
if (put_user(sizeof(*head), len_ptr))
return -EFAULT;
return put_user(head, head_ptr);
err_unlock:
rcu_read_unlock();
return ret;
}
/*
* Process a futex-list entry, check whether it's owned by the
* dying task, and do notification if so:
*/
int handle_futex_death(u32 __user *uaddr, struct task_struct *curr, int pi)
{
u32 uval, uninitialized_var(nval), mval;
retry:
if (get_user(uval, uaddr))
return -1;
if ((uval & FUTEX_TID_MASK) == task_pid_vnr(curr)) {
/*
* Ok, this dying thread is truly holding a futex
* of interest. Set the OWNER_DIED bit atomically
* via cmpxchg, and if the value had FUTEX_WAITERS
* set, wake up a waiter (if any). (We have to do a
* futex_wake() even if OWNER_DIED is already set -
* to handle the rare but possible case of recursive
* thread-death.) The rest of the cleanup is done in
* userspace.
*/
mval = (uval & FUTEX_WAITERS) | FUTEX_OWNER_DIED;
/*
* We are not holding a lock here, but we want to have
* the pagefault_disable/enable() protection because
* we want to handle the fault gracefully. If the
* access fails we try to fault in the futex with R/W
* verification via get_user_pages. get_user() above
* does not guarantee R/W access. If that fails we
* give up and leave the futex locked.
*/
if (cmpxchg_futex_value_locked(&nval, uaddr, uval, mval)) {
if (fault_in_user_writeable(uaddr))
return -1;
goto retry;
}
if (nval != uval)
goto retry;
/*
* Wake robust non-PI futexes here. The wakeup of
* PI futexes happens in exit_pi_state():
*/
if (!pi && (uval & FUTEX_WAITERS))
futex_wake(uaddr, 1, 1, FUTEX_BITSET_MATCH_ANY);
}
return 0;
}
/*
* Fetch a robust-list pointer. Bit 0 signals PI futexes:
*/
static inline int fetch_robust_entry(struct robust_list __user **entry,
struct robust_list __user * __user *head,
unsigned int *pi)
{
unsigned long uentry;
if (get_user(uentry, (unsigned long __user *)head))
return -EFAULT;
*entry = (void __user *)(uentry & ~1UL);
*pi = uentry & 1;
return 0;
}
/*
* Walk curr->robust_list (very carefully, it's a userspace list!)
* and mark any locks found there dead, and notify any waiters.
*
* We silently return on any sign of list-walking problem.
*/
void exit_robust_list(struct task_struct *curr)
{
struct robust_list_head __user *head = curr->robust_list;
struct robust_list __user *entry, *next_entry, *pending;
unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;
unsigned int uninitialized_var(next_pi);
unsigned long futex_offset;
int rc;
if (!futex_cmpxchg_enabled)
return;
/*
* Fetch the list head (which was registered earlier, via
* sys_set_robust_list()):
*/
if (fetch_robust_entry(&entry, &head->list.next, &pi))
return;
/*
* Fetch the relative futex offset:
*/
if (get_user(futex_offset, &head->futex_offset))
return;
/*
* Fetch any possibly pending lock-add first, and handle it
* if it exists:
*/
if (fetch_robust_entry(&pending, &head->list_op_pending, &pip))
return;
next_entry = NULL; /* avoid warning with gcc */
while (entry != &head->list) {
/*
* Fetch the next entry in the list before calling
* handle_futex_death:
*/
rc = fetch_robust_entry(&next_entry, &entry->next, &next_pi);
/*
* A pending lock might already be on the list, so
* don't process it twice:
*/
if (entry != pending)
if (handle_futex_death((void __user *)entry + futex_offset,
curr, pi))
return;
if (rc)
return;
entry = next_entry;
pi = next_pi;
/*
* Avoid excessively long or circular lists:
*/
if (!--limit)
break;
cond_resched();
}
if (pending)
handle_futex_death((void __user *)pending + futex_offset,
curr, pip);
}
long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
u32 __user *uaddr2, u32 val2, u32 val3)
{
int cmd = op & FUTEX_CMD_MASK;
unsigned int flags = 0;
if (!(op & FUTEX_PRIVATE_FLAG))
flags |= FLAGS_SHARED;
if (op & FUTEX_CLOCK_REALTIME) {
flags |= FLAGS_CLOCKRT;
if (cmd != FUTEX_WAIT_BITSET && cmd != FUTEX_WAIT_REQUEUE_PI)
return -ENOSYS;
}
switch (cmd) {
case FUTEX_LOCK_PI:
case FUTEX_UNLOCK_PI:
case FUTEX_TRYLOCK_PI:
case FUTEX_WAIT_REQUEUE_PI:
case FUTEX_CMP_REQUEUE_PI:
if (!futex_cmpxchg_enabled)
return -ENOSYS;
}
switch (cmd) {
case FUTEX_WAIT:
val3 = FUTEX_BITSET_MATCH_ANY;
case FUTEX_WAIT_BITSET:
return futex_wait(uaddr, flags, val, timeout, val3);
case FUTEX_WAKE:
val3 = FUTEX_BITSET_MATCH_ANY;
case FUTEX_WAKE_BITSET:
return futex_wake(uaddr, flags, val, val3);
case FUTEX_REQUEUE:
return futex_requeue(uaddr, flags, uaddr2, val, val2, NULL, 0);
case FUTEX_CMP_REQUEUE:
return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 0);
case FUTEX_WAKE_OP:
return futex_wake_op(uaddr, flags, uaddr2, val, val2, val3);
case FUTEX_LOCK_PI:
return futex_lock_pi(uaddr, flags, val, timeout, 0);
case FUTEX_UNLOCK_PI:
return futex_unlock_pi(uaddr, flags);
case FUTEX_TRYLOCK_PI:
return futex_lock_pi(uaddr, flags, 0, timeout, 1);
case FUTEX_WAIT_REQUEUE_PI:
val3 = FUTEX_BITSET_MATCH_ANY;
return futex_wait_requeue_pi(uaddr, flags, val, timeout, val3,
uaddr2);
case FUTEX_CMP_REQUEUE_PI:
return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 1);
}
return -ENOSYS;
}
SYSCALL_DEFINE6(futex, u32 __user *, uaddr, int, op, u32, val,
struct timespec __user *, utime, u32 __user *, uaddr2,
u32, val3)
{
struct timespec ts;
ktime_t t, *tp = NULL;
u32 val2 = 0;
int cmd = op & FUTEX_CMD_MASK;
if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI ||
cmd == FUTEX_WAIT_BITSET ||
cmd == FUTEX_WAIT_REQUEUE_PI)) {
if (copy_from_user(&ts, utime, sizeof(ts)) != 0)
return -EFAULT;
if (!timespec_valid(&ts))
return -EINVAL;
t = timespec_to_ktime(ts);
if (cmd == FUTEX_WAIT)
t = ktime_add_safe(ktime_get(), t);
tp = &t;
}
/*
* requeue parameter in 'utime' if cmd == FUTEX_*_REQUEUE_*.
* number of waiters to wake in 'utime' if cmd == FUTEX_WAKE_OP.
*/
if (cmd == FUTEX_REQUEUE || cmd == FUTEX_CMP_REQUEUE ||
cmd == FUTEX_CMP_REQUEUE_PI || cmd == FUTEX_WAKE_OP)
val2 = (u32) (unsigned long) utime;
return do_futex(uaddr, op, val, tp, uaddr2, val2, val3);
}
static void __init futex_detect_cmpxchg(void)
{
#ifndef CONFIG_HAVE_FUTEX_CMPXCHG
u32 curval;
/*
* This will fail and we want it. Some arch implementations do
* runtime detection of the futex_atomic_cmpxchg_inatomic()
* functionality. We want to know that before we call in any
* of the complex code paths. Also we want to prevent
* registration of robust lists in that case. NULL is
* guaranteed to fault and we get -EFAULT on functional
* implementation, the non-functional ones will return
* -ENOSYS.
*/
if (cmpxchg_futex_value_locked(&curval, NULL, 0, 0) == -EFAULT)
futex_cmpxchg_enabled = 1;
#endif
}
static int __init futex_init(void)
{
int i;
futex_detect_cmpxchg();
for (i = 0; i < ARRAY_SIZE(futex_queues); i++) {
plist_head_init(&futex_queues[i].chain);
spin_lock_init(&futex_queues[i].lock);
}
return 0;
}
__initcall(futex_init);
| Java |
/* Automatically generated from ../src/remote/remote_protocol.x by gendispatch.pl.
* Do not edit this file. Any changes you make will be lost.
*/
static int remoteDispatchAuthList(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_auth_list_ret *ret);
static int remoteDispatchAuthListHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchAuthList(server, client, msg, rerr, ret);
}
/* remoteDispatchAuthList body has to be implemented manually */
static int remoteDispatchAuthPolkit(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_auth_polkit_ret *ret);
static int remoteDispatchAuthPolkitHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchAuthPolkit(server, client, msg, rerr, ret);
}
/* remoteDispatchAuthPolkit body has to be implemented manually */
static int remoteDispatchAuthSaslInit(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_auth_sasl_init_ret *ret);
static int remoteDispatchAuthSaslInitHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchAuthSaslInit(server, client, msg, rerr, ret);
}
/* remoteDispatchAuthSaslInit body has to be implemented manually */
static int remoteDispatchAuthSaslStart(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_auth_sasl_start_args *args,
remote_auth_sasl_start_ret *ret);
static int remoteDispatchAuthSaslStartHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchAuthSaslStart(server, client, msg, rerr, args, ret);
}
/* remoteDispatchAuthSaslStart body has to be implemented manually */
static int remoteDispatchAuthSaslStep(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_auth_sasl_step_args *args,
remote_auth_sasl_step_ret *ret);
static int remoteDispatchAuthSaslStepHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchAuthSaslStep(server, client, msg, rerr, args, ret);
}
/* remoteDispatchAuthSaslStep body has to be implemented manually */
static int remoteDispatchConnectBaselineCPU(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_baseline_cpu_args *args,
remote_connect_baseline_cpu_ret *ret);
static int remoteDispatchConnectBaselineCPUHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectBaselineCPU(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectBaselineCPU(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_baseline_cpu_args *args,
remote_connect_baseline_cpu_ret *ret)
{
int rv = -1;
char *cpu;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((cpu = virConnectBaselineCPU(priv->conn, (const char **) args->xmlCPUs.xmlCPUs_val, args->xmlCPUs.xmlCPUs_len, args->flags)) == NULL)
goto cleanup;
ret->cpu = cpu;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectClose(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr);
static int remoteDispatchConnectCloseHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectClose(server, client, msg, rerr);
}
/* remoteDispatchConnectClose body has to be implemented manually */
static int remoteDispatchConnectCompareCPU(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_compare_cpu_args *args,
remote_connect_compare_cpu_ret *ret);
static int remoteDispatchConnectCompareCPUHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectCompareCPU(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectCompareCPU(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_compare_cpu_args *args,
remote_connect_compare_cpu_ret *ret)
{
int rv = -1;
int result;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((result = virConnectCompareCPU(priv->conn, args->xml, args->flags)) < 0)
goto cleanup;
ret->result = result;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectDomainEventCallbackDeregisterAny(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_domain_event_callback_deregister_any_args *args);
static int remoteDispatchConnectDomainEventCallbackDeregisterAnyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectDomainEventCallbackDeregisterAny(server, client, msg, rerr, args);
}
/* remoteDispatchConnectDomainEventCallbackDeregisterAny body has to be implemented manually */
static int remoteDispatchConnectDomainEventCallbackRegisterAny(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_domain_event_callback_register_any_args *args,
remote_connect_domain_event_callback_register_any_ret *ret);
static int remoteDispatchConnectDomainEventCallbackRegisterAnyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectDomainEventCallbackRegisterAny(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectDomainEventCallbackRegisterAny body has to be implemented manually */
static int remoteDispatchConnectDomainEventDeregister(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_domain_event_deregister_ret *ret);
static int remoteDispatchConnectDomainEventDeregisterHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectDomainEventDeregister(server, client, msg, rerr, ret);
}
/* remoteDispatchConnectDomainEventDeregister body has to be implemented manually */
static int remoteDispatchConnectDomainEventDeregisterAny(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_domain_event_deregister_any_args *args);
static int remoteDispatchConnectDomainEventDeregisterAnyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectDomainEventDeregisterAny(server, client, msg, rerr, args);
}
/* remoteDispatchConnectDomainEventDeregisterAny body has to be implemented manually */
static int remoteDispatchConnectDomainEventRegister(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_domain_event_register_ret *ret);
static int remoteDispatchConnectDomainEventRegisterHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectDomainEventRegister(server, client, msg, rerr, ret);
}
/* remoteDispatchConnectDomainEventRegister body has to be implemented manually */
static int remoteDispatchConnectDomainEventRegisterAny(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_domain_event_register_any_args *args);
static int remoteDispatchConnectDomainEventRegisterAnyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectDomainEventRegisterAny(server, client, msg, rerr, args);
}
/* remoteDispatchConnectDomainEventRegisterAny body has to be implemented manually */
static int remoteDispatchConnectDomainXMLFromNative(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_domain_xml_from_native_args *args,
remote_connect_domain_xml_from_native_ret *ret);
static int remoteDispatchConnectDomainXMLFromNativeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectDomainXMLFromNative(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectDomainXMLFromNative(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_domain_xml_from_native_args *args,
remote_connect_domain_xml_from_native_ret *ret)
{
int rv = -1;
char *domainXml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((domainXml = virConnectDomainXMLFromNative(priv->conn, args->nativeFormat, args->nativeConfig, args->flags)) == NULL)
goto cleanup;
ret->domainXml = domainXml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectDomainXMLToNative(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_domain_xml_to_native_args *args,
remote_connect_domain_xml_to_native_ret *ret);
static int remoteDispatchConnectDomainXMLToNativeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectDomainXMLToNative(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectDomainXMLToNative(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_domain_xml_to_native_args *args,
remote_connect_domain_xml_to_native_ret *ret)
{
int rv = -1;
char *nativeConfig;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((nativeConfig = virConnectDomainXMLToNative(priv->conn, args->nativeFormat, args->domainXml, args->flags)) == NULL)
goto cleanup;
ret->nativeConfig = nativeConfig;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectFindStoragePoolSources(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_find_storage_pool_sources_args *args,
remote_connect_find_storage_pool_sources_ret *ret);
static int remoteDispatchConnectFindStoragePoolSourcesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectFindStoragePoolSources(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectFindStoragePoolSources(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_find_storage_pool_sources_args *args,
remote_connect_find_storage_pool_sources_ret *ret)
{
int rv = -1;
char *srcSpec;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
srcSpec = args->srcSpec ? *args->srcSpec : NULL;
if ((xml = virConnectFindStoragePoolSources(priv->conn, args->type, srcSpec, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectGetCapabilities(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_capabilities_ret *ret);
static int remoteDispatchConnectGetCapabilitiesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetCapabilities(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectGetCapabilities(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_get_capabilities_ret *ret)
{
int rv = -1;
char *capabilities;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((capabilities = virConnectGetCapabilities(priv->conn)) == NULL)
goto cleanup;
ret->capabilities = capabilities;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectGetCPUModelNames(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_cpu_model_names_args *args,
remote_connect_get_cpu_model_names_ret *ret);
static int remoteDispatchConnectGetCPUModelNamesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetCPUModelNames(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectGetCPUModelNames body has to be implemented manually */
static int remoteDispatchConnectGetHostname(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_hostname_ret *ret);
static int remoteDispatchConnectGetHostnameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetHostname(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectGetHostname(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_get_hostname_ret *ret)
{
int rv = -1;
char *hostname;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((hostname = virConnectGetHostname(priv->conn)) == NULL)
goto cleanup;
ret->hostname = hostname;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectGetLibVersion(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_lib_version_ret *ret);
static int remoteDispatchConnectGetLibVersionHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetLibVersion(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectGetLibVersion(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_get_lib_version_ret *ret)
{
int rv = -1;
unsigned long lib_ver;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virConnectGetLibVersion(priv->conn, &lib_ver) < 0)
goto cleanup;
HYPER_TO_ULONG(ret->lib_ver, lib_ver);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectGetMaxVcpus(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_max_vcpus_args *args,
remote_connect_get_max_vcpus_ret *ret);
static int remoteDispatchConnectGetMaxVcpusHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetMaxVcpus(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectGetMaxVcpus(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_get_max_vcpus_args *args,
remote_connect_get_max_vcpus_ret *ret)
{
int rv = -1;
char *type;
int max_vcpus;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
type = args->type ? *args->type : NULL;
if ((max_vcpus = virConnectGetMaxVcpus(priv->conn, type)) < 0)
goto cleanup;
ret->max_vcpus = max_vcpus;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectGetSysinfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_sysinfo_args *args,
remote_connect_get_sysinfo_ret *ret);
static int remoteDispatchConnectGetSysinfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetSysinfo(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectGetSysinfo(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_get_sysinfo_args *args,
remote_connect_get_sysinfo_ret *ret)
{
int rv = -1;
char *sysinfo;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((sysinfo = virConnectGetSysinfo(priv->conn, args->flags)) == NULL)
goto cleanup;
ret->sysinfo = sysinfo;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectGetType(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_type_ret *ret);
static int remoteDispatchConnectGetTypeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetType(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectGetType(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_get_type_ret *ret)
{
int rv = -1;
const char *type;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((type = virConnectGetType(priv->conn)) == NULL)
goto cleanup;
/* We have to VIR_STRDUP because remoteDispatchClientRequest will
* free this string after it's been serialised. */
if (VIR_STRDUP(ret->type, type) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectGetURI(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_uri_ret *ret);
static int remoteDispatchConnectGetURIHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetURI(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectGetURI(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_get_uri_ret *ret)
{
int rv = -1;
char *uri;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((uri = virConnectGetURI(priv->conn)) == NULL)
goto cleanup;
ret->uri = uri;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectGetVersion(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_get_version_ret *ret);
static int remoteDispatchConnectGetVersionHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectGetVersion(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectGetVersion(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_get_version_ret *ret)
{
int rv = -1;
unsigned long hv_ver;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virConnectGetVersion(priv->conn, &hv_ver) < 0)
goto cleanup;
HYPER_TO_ULONG(ret->hv_ver, hv_ver);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectIsSecure(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_is_secure_ret *ret);
static int remoteDispatchConnectIsSecureHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectIsSecure(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectIsSecure(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_is_secure_ret *ret)
{
int rv = -1;
int secure;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((secure = virConnectIsSecure(priv->conn)) < 0)
goto cleanup;
ret->secure = secure;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectListAllDomains(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_all_domains_args *args,
remote_connect_list_all_domains_ret *ret);
static int remoteDispatchConnectListAllDomainsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListAllDomains(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectListAllDomains body has to be implemented manually */
static int remoteDispatchConnectListAllInterfaces(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_all_interfaces_args *args,
remote_connect_list_all_interfaces_ret *ret);
static int remoteDispatchConnectListAllInterfacesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListAllInterfaces(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectListAllInterfaces body has to be implemented manually */
static int remoteDispatchConnectListAllNetworks(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_all_networks_args *args,
remote_connect_list_all_networks_ret *ret);
static int remoteDispatchConnectListAllNetworksHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListAllNetworks(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectListAllNetworks body has to be implemented manually */
static int remoteDispatchConnectListAllNodeDevices(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_all_node_devices_args *args,
remote_connect_list_all_node_devices_ret *ret);
static int remoteDispatchConnectListAllNodeDevicesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListAllNodeDevices(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectListAllNodeDevices body has to be implemented manually */
static int remoteDispatchConnectListAllNWFilters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_all_nwfilters_args *args,
remote_connect_list_all_nwfilters_ret *ret);
static int remoteDispatchConnectListAllNWFiltersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListAllNWFilters(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectListAllNWFilters body has to be implemented manually */
static int remoteDispatchConnectListAllSecrets(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_all_secrets_args *args,
remote_connect_list_all_secrets_ret *ret);
static int remoteDispatchConnectListAllSecretsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListAllSecrets(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectListAllSecrets body has to be implemented manually */
static int remoteDispatchConnectListAllStoragePools(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_all_storage_pools_args *args,
remote_connect_list_all_storage_pools_ret *ret);
static int remoteDispatchConnectListAllStoragePoolsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListAllStoragePools(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectListAllStoragePools body has to be implemented manually */
static int remoteDispatchConnectListDefinedDomains(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_defined_domains_args *args,
remote_connect_list_defined_domains_ret *ret);
static int remoteDispatchConnectListDefinedDomainsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListDefinedDomains(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListDefinedDomains(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_defined_domains_args *args,
remote_connect_list_defined_domains_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_DOMAIN_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_DOMAIN_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virConnectListDefinedDomains(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchConnectListDefinedInterfaces(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_defined_interfaces_args *args,
remote_connect_list_defined_interfaces_ret *ret);
static int remoteDispatchConnectListDefinedInterfacesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListDefinedInterfaces(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListDefinedInterfaces(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_defined_interfaces_args *args,
remote_connect_list_defined_interfaces_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_INTERFACE_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_INTERFACE_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virConnectListDefinedInterfaces(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchConnectListDefinedNetworks(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_defined_networks_args *args,
remote_connect_list_defined_networks_ret *ret);
static int remoteDispatchConnectListDefinedNetworksHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListDefinedNetworks(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListDefinedNetworks(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_defined_networks_args *args,
remote_connect_list_defined_networks_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_NETWORK_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_NETWORK_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virConnectListDefinedNetworks(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchConnectListDefinedStoragePools(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_defined_storage_pools_args *args,
remote_connect_list_defined_storage_pools_ret *ret);
static int remoteDispatchConnectListDefinedStoragePoolsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListDefinedStoragePools(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListDefinedStoragePools(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_defined_storage_pools_args *args,
remote_connect_list_defined_storage_pools_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_STORAGE_POOL_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_STORAGE_POOL_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virConnectListDefinedStoragePools(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchConnectListDomains(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_domains_args *args,
remote_connect_list_domains_ret *ret);
static int remoteDispatchConnectListDomainsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListDomains(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListDomains(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_domains_args *args,
remote_connect_list_domains_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxids > REMOTE_DOMAIN_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxids > REMOTE_DOMAIN_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->ids.ids_val, args->maxids) < 0)
goto cleanup;
if ((len = virConnectListDomains(priv->conn, ret->ids.ids_val, args->maxids)) < 0)
goto cleanup;
ret->ids.ids_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->ids.ids_val);
}
return rv;
}
static int remoteDispatchConnectListInterfaces(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_interfaces_args *args,
remote_connect_list_interfaces_ret *ret);
static int remoteDispatchConnectListInterfacesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListInterfaces(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListInterfaces(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_interfaces_args *args,
remote_connect_list_interfaces_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_INTERFACE_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_INTERFACE_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virConnectListInterfaces(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchConnectListNetworks(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_networks_args *args,
remote_connect_list_networks_ret *ret);
static int remoteDispatchConnectListNetworksHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListNetworks(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListNetworks(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_networks_args *args,
remote_connect_list_networks_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_NETWORK_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_NETWORK_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virConnectListNetworks(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchConnectListNWFilters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_nwfilters_args *args,
remote_connect_list_nwfilters_ret *ret);
static int remoteDispatchConnectListNWFiltersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListNWFilters(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListNWFilters(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_nwfilters_args *args,
remote_connect_list_nwfilters_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_NWFILTER_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_NWFILTER_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virConnectListNWFilters(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchConnectListSecrets(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_secrets_args *args,
remote_connect_list_secrets_ret *ret);
static int remoteDispatchConnectListSecretsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListSecrets(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListSecrets(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_secrets_args *args,
remote_connect_list_secrets_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxuuids > REMOTE_SECRET_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxuuids > REMOTE_SECRET_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->uuids.uuids_val, args->maxuuids) < 0)
goto cleanup;
if ((len = virConnectListSecrets(priv->conn, ret->uuids.uuids_val, args->maxuuids)) < 0)
goto cleanup;
ret->uuids.uuids_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->uuids.uuids_val);
}
return rv;
}
static int remoteDispatchConnectListStoragePools(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_list_storage_pools_args *args,
remote_connect_list_storage_pools_ret *ret);
static int remoteDispatchConnectListStoragePoolsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectListStoragePools(server, client, msg, rerr, args, ret);
}
static int remoteDispatchConnectListStoragePools(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_list_storage_pools_args *args,
remote_connect_list_storage_pools_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_STORAGE_POOL_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_STORAGE_POOL_LIST_MAX"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virConnectListStoragePools(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchConnectNetworkEventDeregisterAny(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_network_event_deregister_any_args *args);
static int remoteDispatchConnectNetworkEventDeregisterAnyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNetworkEventDeregisterAny(server, client, msg, rerr, args);
}
/* remoteDispatchConnectNetworkEventDeregisterAny body has to be implemented manually */
static int remoteDispatchConnectNetworkEventRegisterAny(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_network_event_register_any_args *args,
remote_connect_network_event_register_any_ret *ret);
static int remoteDispatchConnectNetworkEventRegisterAnyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNetworkEventRegisterAny(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectNetworkEventRegisterAny body has to be implemented manually */
static int remoteDispatchConnectNumOfDefinedDomains(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_defined_domains_ret *ret);
static int remoteDispatchConnectNumOfDefinedDomainsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfDefinedDomains(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfDefinedDomains(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_defined_domains_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfDefinedDomains(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfDefinedInterfaces(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_defined_interfaces_ret *ret);
static int remoteDispatchConnectNumOfDefinedInterfacesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfDefinedInterfaces(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfDefinedInterfaces(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_defined_interfaces_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfDefinedInterfaces(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfDefinedNetworks(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_defined_networks_ret *ret);
static int remoteDispatchConnectNumOfDefinedNetworksHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfDefinedNetworks(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfDefinedNetworks(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_defined_networks_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfDefinedNetworks(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfDefinedStoragePools(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_defined_storage_pools_ret *ret);
static int remoteDispatchConnectNumOfDefinedStoragePoolsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfDefinedStoragePools(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfDefinedStoragePools(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_defined_storage_pools_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfDefinedStoragePools(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfDomains(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_domains_ret *ret);
static int remoteDispatchConnectNumOfDomainsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfDomains(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfDomains(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_domains_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfDomains(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfInterfaces(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_interfaces_ret *ret);
static int remoteDispatchConnectNumOfInterfacesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfInterfaces(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfInterfaces(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_interfaces_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfInterfaces(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfNetworks(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_networks_ret *ret);
static int remoteDispatchConnectNumOfNetworksHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfNetworks(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfNetworks(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_networks_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfNetworks(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfNWFilters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_nwfilters_ret *ret);
static int remoteDispatchConnectNumOfNWFiltersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfNWFilters(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfNWFilters(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_nwfilters_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfNWFilters(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfSecrets(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_secrets_ret *ret);
static int remoteDispatchConnectNumOfSecretsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfSecrets(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfSecrets(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_secrets_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfSecrets(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectNumOfStoragePools(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_num_of_storage_pools_ret *ret);
static int remoteDispatchConnectNumOfStoragePoolsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectNumOfStoragePools(server, client, msg, rerr, ret);
}
static int remoteDispatchConnectNumOfStoragePools(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_connect_num_of_storage_pools_ret *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((num = virConnectNumOfStoragePools(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchConnectOpen(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_open_args *args);
static int remoteDispatchConnectOpenHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectOpen(server, client, msg, rerr, args);
}
/* remoteDispatchConnectOpen body has to be implemented manually */
static int remoteDispatchConnectSupportsFeature(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_connect_supports_feature_args *args,
remote_connect_supports_feature_ret *ret);
static int remoteDispatchConnectSupportsFeatureHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchConnectSupportsFeature(server, client, msg, rerr, args, ret);
}
/* remoteDispatchConnectSupportsFeature body has to be implemented manually */
static int remoteDispatchDomainAbortJob(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_abort_job_args *args);
static int remoteDispatchDomainAbortJobHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainAbortJob(server, client, msg, rerr, args);
}
static int remoteDispatchDomainAbortJob(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_abort_job_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainAbortJob(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainAttachDevice(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_attach_device_args *args);
static int remoteDispatchDomainAttachDeviceHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainAttachDevice(server, client, msg, rerr, args);
}
static int remoteDispatchDomainAttachDevice(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_attach_device_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainAttachDevice(dom, args->xml) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainAttachDeviceFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_attach_device_flags_args *args);
static int remoteDispatchDomainAttachDeviceFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainAttachDeviceFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainAttachDeviceFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_attach_device_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainAttachDeviceFlags(dom, args->xml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainBlockCommit(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_commit_args *args);
static int remoteDispatchDomainBlockCommitHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockCommit(server, client, msg, rerr, args);
}
static int remoteDispatchDomainBlockCommit(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_block_commit_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *base;
char *top;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
base = args->base ? *args->base : NULL;
top = args->top ? *args->top : NULL;
if (virDomainBlockCommit(dom, args->disk, base, top, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainBlockJobAbort(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_job_abort_args *args);
static int remoteDispatchDomainBlockJobAbortHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockJobAbort(server, client, msg, rerr, args);
}
static int remoteDispatchDomainBlockJobAbort(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_block_job_abort_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainBlockJobAbort(dom, args->path, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainBlockJobSetSpeed(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_job_set_speed_args *args);
static int remoteDispatchDomainBlockJobSetSpeedHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockJobSetSpeed(server, client, msg, rerr, args);
}
static int remoteDispatchDomainBlockJobSetSpeed(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_block_job_set_speed_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
if (virDomainBlockJobSetSpeed(dom, args->path, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainBlockPeek(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_peek_args *args,
remote_domain_block_peek_ret *ret);
static int remoteDispatchDomainBlockPeekHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockPeek(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainBlockPeek body has to be implemented manually */
static int remoteDispatchDomainBlockPull(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_pull_args *args);
static int remoteDispatchDomainBlockPullHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockPull(server, client, msg, rerr, args);
}
static int remoteDispatchDomainBlockPull(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_block_pull_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
if (virDomainBlockPull(dom, args->path, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainBlockRebase(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_rebase_args *args);
static int remoteDispatchDomainBlockRebaseHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockRebase(server, client, msg, rerr, args);
}
static int remoteDispatchDomainBlockRebase(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_block_rebase_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *base;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
base = args->base ? *args->base : NULL;
if (virDomainBlockRebase(dom, args->path, base, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainBlockResize(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_resize_args *args);
static int remoteDispatchDomainBlockResizeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockResize(server, client, msg, rerr, args);
}
static int remoteDispatchDomainBlockResize(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_block_resize_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainBlockResize(dom, args->disk, args->size, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainBlockStats(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_stats_args *args,
remote_domain_block_stats_ret *ret);
static int remoteDispatchDomainBlockStatsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockStats(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainBlockStats(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_block_stats_args *args,
remote_domain_block_stats_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainBlockStatsStruct tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainBlockStats(dom, args->path, &tmp, sizeof(tmp)) < 0)
goto cleanup;
ret->rd_req = tmp.rd_req;
ret->rd_bytes = tmp.rd_bytes;
ret->wr_req = tmp.wr_req;
ret->wr_bytes = tmp.wr_bytes;
ret->errs = tmp.errs;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainBlockStatsFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_block_stats_flags_args *args,
remote_domain_block_stats_flags_ret *ret);
static int remoteDispatchDomainBlockStatsFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainBlockStatsFlags(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainBlockStatsFlags body has to be implemented manually */
static int remoteDispatchDomainCoreDump(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_core_dump_args *args);
static int remoteDispatchDomainCoreDumpHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainCoreDump(server, client, msg, rerr, args);
}
static int remoteDispatchDomainCoreDump(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_core_dump_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainCoreDump(dom, args->to, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainCoreDumpWithFormat(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_core_dump_with_format_args *args);
static int remoteDispatchDomainCoreDumpWithFormatHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainCoreDumpWithFormat(server, client, msg, rerr, args);
}
static int remoteDispatchDomainCoreDumpWithFormat(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_core_dump_with_format_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainCoreDumpWithFormat(dom, args->to, args->dumpformat, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainCreate(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_create_args *args);
static int remoteDispatchDomainCreateHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainCreate(server, client, msg, rerr, args);
}
static int remoteDispatchDomainCreate(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_create_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainCreate(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainCreateWithFiles(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_create_with_files_args *args,
remote_domain_create_with_files_ret *ret);
static int remoteDispatchDomainCreateWithFilesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainCreateWithFiles(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainCreateWithFiles body has to be implemented manually */
static int remoteDispatchDomainCreateWithFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_create_with_flags_args *args,
remote_domain_create_with_flags_ret *ret);
static int remoteDispatchDomainCreateWithFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainCreateWithFlags(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainCreateWithFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_create_with_flags_args *args,
remote_domain_create_with_flags_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainCreateWithFlags(dom, args->flags) < 0)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainCreateXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_create_xml_args *args,
remote_domain_create_xml_ret *ret);
static int remoteDispatchDomainCreateXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainCreateXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainCreateXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_create_xml_args *args,
remote_domain_create_xml_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = virDomainCreateXML(priv->conn, args->xml_desc, args->flags)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainCreateXMLWithFiles(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_create_xml_with_files_args *args,
remote_domain_create_xml_with_files_ret *ret);
static int remoteDispatchDomainCreateXMLWithFilesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainCreateXMLWithFiles(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainCreateXMLWithFiles body has to be implemented manually */
static int remoteDispatchDomainDefineXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_define_xml_args *args,
remote_domain_define_xml_ret *ret);
static int remoteDispatchDomainDefineXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainDefineXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainDefineXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_define_xml_args *args,
remote_domain_define_xml_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = virDomainDefineXML(priv->conn, args->xml)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainDestroy(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_destroy_args *args);
static int remoteDispatchDomainDestroyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainDestroy(server, client, msg, rerr, args);
}
static int remoteDispatchDomainDestroy(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_destroy_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainDestroy(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainDestroyFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_destroy_flags_args *args);
static int remoteDispatchDomainDestroyFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainDestroyFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainDestroyFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_destroy_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainDestroyFlags(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainDetachDevice(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_detach_device_args *args);
static int remoteDispatchDomainDetachDeviceHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainDetachDevice(server, client, msg, rerr, args);
}
static int remoteDispatchDomainDetachDevice(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_detach_device_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainDetachDevice(dom, args->xml) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainDetachDeviceFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_detach_device_flags_args *args);
static int remoteDispatchDomainDetachDeviceFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainDetachDeviceFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainDetachDeviceFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_detach_device_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainDetachDeviceFlags(dom, args->xml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainFSTrim(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_fstrim_args *args);
static int remoteDispatchDomainFSTrimHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainFSTrim(server, client, msg, rerr, args);
}
static int remoteDispatchDomainFSTrim(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_fstrim_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *mountPoint;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
mountPoint = args->mountPoint ? *args->mountPoint : NULL;
if (virDomainFSTrim(dom, mountPoint, args->minimum, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetAutostart(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_autostart_args *args,
remote_domain_get_autostart_ret *ret);
static int remoteDispatchDomainGetAutostartHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetAutostart(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetAutostart(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_autostart_args *args,
remote_domain_get_autostart_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int autostart;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainGetAutostart(dom, &autostart) < 0)
goto cleanup;
ret->autostart = autostart;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetBlkioParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_blkio_parameters_args *args,
remote_domain_get_blkio_parameters_ret *ret);
static int remoteDispatchDomainGetBlkioParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetBlkioParameters(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetBlkioParameters body has to be implemented manually */
static int remoteDispatchDomainGetBlockInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_block_info_args *args,
remote_domain_get_block_info_ret *ret);
static int remoteDispatchDomainGetBlockInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetBlockInfo(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetBlockInfo(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_block_info_args *args,
remote_domain_get_block_info_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainBlockInfo tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainGetBlockInfo(dom, args->path, &tmp, args->flags) < 0)
goto cleanup;
ret->allocation = tmp.allocation;
ret->capacity = tmp.capacity;
ret->physical = tmp.physical;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetBlockIoTune(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_block_io_tune_args *args,
remote_domain_get_block_io_tune_ret *ret);
static int remoteDispatchDomainGetBlockIoTuneHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetBlockIoTune(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetBlockIoTune body has to be implemented manually */
static int remoteDispatchDomainGetBlockJobInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_block_job_info_args *args,
remote_domain_get_block_job_info_ret *ret);
static int remoteDispatchDomainGetBlockJobInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetBlockJobInfo(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetBlockJobInfo body has to be implemented manually */
static int remoteDispatchDomainGetControlInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_control_info_args *args,
remote_domain_get_control_info_ret *ret);
static int remoteDispatchDomainGetControlInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetControlInfo(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetControlInfo(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_control_info_args *args,
remote_domain_get_control_info_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainControlInfo tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainGetControlInfo(dom, &tmp, args->flags) < 0)
goto cleanup;
ret->state = tmp.state;
ret->details = tmp.details;
ret->stateTime = tmp.stateTime;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetCPUStats(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_cpu_stats_args *args,
remote_domain_get_cpu_stats_ret *ret);
static int remoteDispatchDomainGetCPUStatsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetCPUStats(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetCPUStats body has to be implemented manually */
static int remoteDispatchDomainGetDiskErrors(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_disk_errors_args *args,
remote_domain_get_disk_errors_ret *ret);
static int remoteDispatchDomainGetDiskErrorsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetDiskErrors(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetDiskErrors body has to be implemented manually */
static int remoteDispatchDomainGetEmulatorPinInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_emulator_pin_info_args *args,
remote_domain_get_emulator_pin_info_ret *ret);
static int remoteDispatchDomainGetEmulatorPinInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetEmulatorPinInfo(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetEmulatorPinInfo body has to be implemented manually */
static int remoteDispatchDomainGetHostname(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_hostname_args *args,
remote_domain_get_hostname_ret *ret);
static int remoteDispatchDomainGetHostnameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetHostname(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetHostname(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_hostname_args *args,
remote_domain_get_hostname_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *hostname;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((hostname = virDomainGetHostname(dom, args->flags)) == NULL)
goto cleanup;
ret->hostname = hostname;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_info_args *args,
remote_domain_get_info_ret *ret);
static int remoteDispatchDomainGetInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetInfo(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetInfo(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_info_args *args,
remote_domain_get_info_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainInfo tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainGetInfo(dom, &tmp) < 0)
goto cleanup;
ret->state = tmp.state;
ret->maxMem = tmp.maxMem;
ret->memory = tmp.memory;
ret->nrVirtCpu = tmp.nrVirtCpu;
ret->cpuTime = tmp.cpuTime;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetInterfaceParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_interface_parameters_args *args,
remote_domain_get_interface_parameters_ret *ret);
static int remoteDispatchDomainGetInterfaceParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetInterfaceParameters(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetInterfaceParameters body has to be implemented manually */
static int remoteDispatchDomainGetJobInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_job_info_args *args,
remote_domain_get_job_info_ret *ret);
static int remoteDispatchDomainGetJobInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetJobInfo(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetJobInfo(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_job_info_args *args,
remote_domain_get_job_info_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainJobInfo tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainGetJobInfo(dom, &tmp) < 0)
goto cleanup;
ret->type = tmp.type;
ret->timeElapsed = tmp.timeElapsed;
ret->timeRemaining = tmp.timeRemaining;
ret->dataTotal = tmp.dataTotal;
ret->dataProcessed = tmp.dataProcessed;
ret->dataRemaining = tmp.dataRemaining;
ret->memTotal = tmp.memTotal;
ret->memProcessed = tmp.memProcessed;
ret->memRemaining = tmp.memRemaining;
ret->fileTotal = tmp.fileTotal;
ret->fileProcessed = tmp.fileProcessed;
ret->fileRemaining = tmp.fileRemaining;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetJobStats(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_job_stats_args *args,
remote_domain_get_job_stats_ret *ret);
static int remoteDispatchDomainGetJobStatsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetJobStats(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetJobStats body has to be implemented manually */
static int remoteDispatchDomainGetMaxMemory(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_max_memory_args *args,
remote_domain_get_max_memory_ret *ret);
static int remoteDispatchDomainGetMaxMemoryHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetMaxMemory(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetMaxMemory(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_max_memory_args *args,
remote_domain_get_max_memory_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long long memory;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((memory = virDomainGetMaxMemory(dom)) == 0)
goto cleanup;
ret->memory = memory;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetMaxVcpus(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_max_vcpus_args *args,
remote_domain_get_max_vcpus_ret *ret);
static int remoteDispatchDomainGetMaxVcpusHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetMaxVcpus(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetMaxVcpus(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_max_vcpus_args *args,
remote_domain_get_max_vcpus_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((num = virDomainGetMaxVcpus(dom)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetMemoryParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_memory_parameters_args *args,
remote_domain_get_memory_parameters_ret *ret);
static int remoteDispatchDomainGetMemoryParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetMemoryParameters(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetMemoryParameters body has to be implemented manually */
static int remoteDispatchDomainGetMetadata(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_metadata_args *args,
remote_domain_get_metadata_ret *ret);
static int remoteDispatchDomainGetMetadataHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetMetadata(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetMetadata(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_metadata_args *args,
remote_domain_get_metadata_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *uri;
char *metadata;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
uri = args->uri ? *args->uri : NULL;
if ((metadata = virDomainGetMetadata(dom, args->type, uri, args->flags)) == NULL)
goto cleanup;
ret->metadata = metadata;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetNumaParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_numa_parameters_args *args,
remote_domain_get_numa_parameters_ret *ret);
static int remoteDispatchDomainGetNumaParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetNumaParameters(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetNumaParameters body has to be implemented manually */
static int remoteDispatchDomainGetOSType(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_os_type_args *args,
remote_domain_get_os_type_ret *ret);
static int remoteDispatchDomainGetOSTypeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetOSType(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetOSType(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_os_type_args *args,
remote_domain_get_os_type_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *type;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((type = virDomainGetOSType(dom)) == NULL)
goto cleanup;
ret->type = type;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetSchedulerParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_scheduler_parameters_args *args,
remote_domain_get_scheduler_parameters_ret *ret);
static int remoteDispatchDomainGetSchedulerParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetSchedulerParameters(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetSchedulerParameters body has to be implemented manually */
static int remoteDispatchDomainGetSchedulerParametersFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_scheduler_parameters_flags_args *args,
remote_domain_get_scheduler_parameters_flags_ret *ret);
static int remoteDispatchDomainGetSchedulerParametersFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetSchedulerParametersFlags(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetSchedulerParametersFlags body has to be implemented manually */
static int remoteDispatchDomainGetSchedulerType(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_scheduler_type_args *args,
remote_domain_get_scheduler_type_ret *ret);
static int remoteDispatchDomainGetSchedulerTypeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetSchedulerType(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetSchedulerType body has to be implemented manually */
static int remoteDispatchDomainGetSecurityLabel(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_security_label_args *args,
remote_domain_get_security_label_ret *ret);
static int remoteDispatchDomainGetSecurityLabelHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetSecurityLabel(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetSecurityLabel body has to be implemented manually */
static int remoteDispatchDomainGetSecurityLabelList(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_security_label_list_args *args,
remote_domain_get_security_label_list_ret *ret);
static int remoteDispatchDomainGetSecurityLabelListHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetSecurityLabelList(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetSecurityLabelList body has to be implemented manually */
static int remoteDispatchDomainGetState(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_state_args *args,
remote_domain_get_state_ret *ret);
static int remoteDispatchDomainGetStateHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetState(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetState body has to be implemented manually */
static int remoteDispatchDomainGetVcpuPinInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_vcpu_pin_info_args *args,
remote_domain_get_vcpu_pin_info_ret *ret);
static int remoteDispatchDomainGetVcpuPinInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetVcpuPinInfo(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetVcpuPinInfo body has to be implemented manually */
static int remoteDispatchDomainGetVcpus(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_vcpus_args *args,
remote_domain_get_vcpus_ret *ret);
static int remoteDispatchDomainGetVcpusHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetVcpus(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainGetVcpus body has to be implemented manually */
static int remoteDispatchDomainGetVcpusFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_vcpus_flags_args *args,
remote_domain_get_vcpus_flags_ret *ret);
static int remoteDispatchDomainGetVcpusFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetVcpusFlags(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetVcpusFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_vcpus_flags_args *args,
remote_domain_get_vcpus_flags_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((num = virDomainGetVcpusFlags(dom, args->flags)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_get_xml_desc_args *args,
remote_domain_get_xml_desc_ret *ret);
static int remoteDispatchDomainGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_get_xml_desc_args *args,
remote_domain_get_xml_desc_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((xml = virDomainGetXMLDesc(dom, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainHasCurrentSnapshot(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_has_current_snapshot_args *args,
remote_domain_has_current_snapshot_ret *ret);
static int remoteDispatchDomainHasCurrentSnapshotHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainHasCurrentSnapshot(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainHasCurrentSnapshot(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_has_current_snapshot_args *args,
remote_domain_has_current_snapshot_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int result;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((result = virDomainHasCurrentSnapshot(dom, args->flags)) < 0)
goto cleanup;
ret->result = result;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainHasManagedSaveImage(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_has_managed_save_image_args *args,
remote_domain_has_managed_save_image_ret *ret);
static int remoteDispatchDomainHasManagedSaveImageHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainHasManagedSaveImage(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainHasManagedSaveImage(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_has_managed_save_image_args *args,
remote_domain_has_managed_save_image_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int result;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((result = virDomainHasManagedSaveImage(dom, args->flags)) < 0)
goto cleanup;
ret->result = result;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainInjectNMI(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_inject_nmi_args *args);
static int remoteDispatchDomainInjectNMIHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainInjectNMI(server, client, msg, rerr, args);
}
static int remoteDispatchDomainInjectNMI(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_inject_nmi_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainInjectNMI(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainInterfaceStats(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_interface_stats_args *args,
remote_domain_interface_stats_ret *ret);
static int remoteDispatchDomainInterfaceStatsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainInterfaceStats(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainInterfaceStats(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_interface_stats_args *args,
remote_domain_interface_stats_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainInterfaceStatsStruct tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainInterfaceStats(dom, args->path, &tmp, sizeof(tmp)) < 0)
goto cleanup;
ret->rx_bytes = tmp.rx_bytes;
ret->rx_packets = tmp.rx_packets;
ret->rx_errs = tmp.rx_errs;
ret->rx_drop = tmp.rx_drop;
ret->tx_bytes = tmp.tx_bytes;
ret->tx_packets = tmp.tx_packets;
ret->tx_errs = tmp.tx_errs;
ret->tx_drop = tmp.tx_drop;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainIsActive(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_is_active_args *args,
remote_domain_is_active_ret *ret);
static int remoteDispatchDomainIsActiveHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainIsActive(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainIsActive(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_is_active_args *args,
remote_domain_is_active_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int active;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((active = virDomainIsActive(dom)) < 0)
goto cleanup;
ret->active = active;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainIsPersistent(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_is_persistent_args *args,
remote_domain_is_persistent_ret *ret);
static int remoteDispatchDomainIsPersistentHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainIsPersistent(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainIsPersistent(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_is_persistent_args *args,
remote_domain_is_persistent_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int persistent;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((persistent = virDomainIsPersistent(dom)) < 0)
goto cleanup;
ret->persistent = persistent;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainIsUpdated(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_is_updated_args *args,
remote_domain_is_updated_ret *ret);
static int remoteDispatchDomainIsUpdatedHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainIsUpdated(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainIsUpdated(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_is_updated_args *args,
remote_domain_is_updated_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int updated;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((updated = virDomainIsUpdated(dom)) < 0)
goto cleanup;
ret->updated = updated;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainListAllSnapshots(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_list_all_snapshots_args *args,
remote_domain_list_all_snapshots_ret *ret);
static int remoteDispatchDomainListAllSnapshotsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainListAllSnapshots(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainListAllSnapshots body has to be implemented manually */
static int remoteDispatchDomainLookupByID(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_lookup_by_id_args *args,
remote_domain_lookup_by_id_ret *ret);
static int remoteDispatchDomainLookupByIDHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainLookupByID(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainLookupByID(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_lookup_by_id_args *args,
remote_domain_lookup_by_id_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = virDomainLookupByID(priv->conn, args->id)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainLookupByName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_lookup_by_name_args *args,
remote_domain_lookup_by_name_ret *ret);
static int remoteDispatchDomainLookupByNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainLookupByName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainLookupByName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_lookup_by_name_args *args,
remote_domain_lookup_by_name_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = virDomainLookupByName(priv->conn, args->name)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainLookupByUUID(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_lookup_by_uuid_args *args,
remote_domain_lookup_by_uuid_ret *ret);
static int remoteDispatchDomainLookupByUUIDHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainLookupByUUID(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainLookupByUUID(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_lookup_by_uuid_args *args,
remote_domain_lookup_by_uuid_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = virDomainLookupByUUID(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainManagedSave(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_managed_save_args *args);
static int remoteDispatchDomainManagedSaveHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainManagedSave(server, client, msg, rerr, args);
}
static int remoteDispatchDomainManagedSave(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_managed_save_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainManagedSave(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainManagedSaveRemove(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_managed_save_remove_args *args);
static int remoteDispatchDomainManagedSaveRemoveHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainManagedSaveRemove(server, client, msg, rerr, args);
}
static int remoteDispatchDomainManagedSaveRemove(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_managed_save_remove_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainManagedSaveRemove(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainMemoryPeek(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_memory_peek_args *args,
remote_domain_memory_peek_ret *ret);
static int remoteDispatchDomainMemoryPeekHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMemoryPeek(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMemoryPeek body has to be implemented manually */
static int remoteDispatchDomainMemoryStats(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_memory_stats_args *args,
remote_domain_memory_stats_ret *ret);
static int remoteDispatchDomainMemoryStatsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMemoryStats(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMemoryStats body has to be implemented manually */
static int remoteDispatchDomainMigrateBegin3(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_begin3_args *args,
remote_domain_migrate_begin3_ret *ret);
static int remoteDispatchDomainMigrateBegin3Helper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateBegin3(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigrateBegin3 body has to be implemented manually */
static int remoteDispatchDomainMigrateBegin3Params(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_begin3_params_args *args,
remote_domain_migrate_begin3_params_ret *ret);
static int remoteDispatchDomainMigrateBegin3ParamsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateBegin3Params(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigrateBegin3Params body has to be implemented manually */
static int remoteDispatchDomainMigrateConfirm3(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_confirm3_args *args);
static int remoteDispatchDomainMigrateConfirm3Helper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateConfirm3(server, client, msg, rerr, args);
}
/* remoteDispatchDomainMigrateConfirm3 body has to be implemented manually */
static int remoteDispatchDomainMigrateConfirm3Params(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_confirm3_params_args *args);
static int remoteDispatchDomainMigrateConfirm3ParamsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateConfirm3Params(server, client, msg, rerr, args);
}
/* remoteDispatchDomainMigrateConfirm3Params body has to be implemented manually */
static int remoteDispatchDomainMigrateFinish(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_finish_args *args,
remote_domain_migrate_finish_ret *ret);
static int remoteDispatchDomainMigrateFinishHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateFinish(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainMigrateFinish(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_finish_args *args,
remote_domain_migrate_finish_ret *ret)
{
int rv = -1;
unsigned long flags;
virDomainPtr ddom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
HYPER_TO_ULONG(flags, args->flags);
if ((ddom = virDomainMigrateFinish(priv->conn, args->dname, args->cookie.cookie_val, args->cookie.cookie_len, args->uri, flags)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->ddom, ddom);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (ddom)
virDomainFree(ddom);
return rv;
}
static int remoteDispatchDomainMigrateFinish2(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_finish2_args *args,
remote_domain_migrate_finish2_ret *ret);
static int remoteDispatchDomainMigrateFinish2Helper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateFinish2(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainMigrateFinish2(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_finish2_args *args,
remote_domain_migrate_finish2_ret *ret)
{
int rv = -1;
unsigned long flags;
virDomainPtr ddom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
HYPER_TO_ULONG(flags, args->flags);
if ((ddom = virDomainMigrateFinish2(priv->conn, args->dname, args->cookie.cookie_val, args->cookie.cookie_len, args->uri, flags, args->retcode)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->ddom, ddom);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (ddom)
virDomainFree(ddom);
return rv;
}
static int remoteDispatchDomainMigrateFinish3(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_finish3_args *args,
remote_domain_migrate_finish3_ret *ret);
static int remoteDispatchDomainMigrateFinish3Helper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateFinish3(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigrateFinish3 body has to be implemented manually */
static int remoteDispatchDomainMigrateFinish3Params(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_finish3_params_args *args,
remote_domain_migrate_finish3_params_ret *ret);
static int remoteDispatchDomainMigrateFinish3ParamsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateFinish3Params(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigrateFinish3Params body has to be implemented manually */
static int remoteDispatchDomainMigrateGetCompressionCache(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_get_compression_cache_args *args,
remote_domain_migrate_get_compression_cache_ret *ret);
static int remoteDispatchDomainMigrateGetCompressionCacheHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateGetCompressionCache(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainMigrateGetCompressionCache(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_get_compression_cache_args *args,
remote_domain_migrate_get_compression_cache_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long long cacheSize;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainMigrateGetCompressionCache(dom, &cacheSize, args->flags) < 0)
goto cleanup;
ret->cacheSize = cacheSize;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainMigrateGetMaxSpeed(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_get_max_speed_args *args,
remote_domain_migrate_get_max_speed_ret *ret);
static int remoteDispatchDomainMigrateGetMaxSpeedHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateGetMaxSpeed(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainMigrateGetMaxSpeed(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_get_max_speed_args *args,
remote_domain_migrate_get_max_speed_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainMigrateGetMaxSpeed(dom, &bandwidth, args->flags) < 0)
goto cleanup;
HYPER_TO_ULONG(ret->bandwidth, bandwidth);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainMigratePerform(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_perform_args *args);
static int remoteDispatchDomainMigratePerformHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePerform(server, client, msg, rerr, args);
}
static int remoteDispatchDomainMigratePerform(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_perform_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long flags;
char *dname;
unsigned long resource;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(flags, args->flags);
HYPER_TO_ULONG(resource, args->resource);
dname = args->dname ? *args->dname : NULL;
if (virDomainMigratePerform(dom, args->cookie.cookie_val, args->cookie.cookie_len, args->uri, flags, dname, resource) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainMigratePerform3(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_perform3_args *args,
remote_domain_migrate_perform3_ret *ret);
static int remoteDispatchDomainMigratePerform3Helper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePerform3(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigratePerform3 body has to be implemented manually */
static int remoteDispatchDomainMigratePerform3Params(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_perform3_params_args *args,
remote_domain_migrate_perform3_params_ret *ret);
static int remoteDispatchDomainMigratePerform3ParamsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePerform3Params(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigratePerform3Params body has to be implemented manually */
static int remoteDispatchDomainMigratePrepare(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare_args *args,
remote_domain_migrate_prepare_ret *ret);
static int remoteDispatchDomainMigratePrepareHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePrepare(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigratePrepare body has to be implemented manually */
static int remoteDispatchDomainMigratePrepare2(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare2_args *args,
remote_domain_migrate_prepare2_ret *ret);
static int remoteDispatchDomainMigratePrepare2Helper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePrepare2(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigratePrepare2 body has to be implemented manually */
static int remoteDispatchDomainMigratePrepare3(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare3_args *args,
remote_domain_migrate_prepare3_ret *ret);
static int remoteDispatchDomainMigratePrepare3Helper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePrepare3(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigratePrepare3 body has to be implemented manually */
static int remoteDispatchDomainMigratePrepare3Params(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare3_params_args *args,
remote_domain_migrate_prepare3_params_ret *ret);
static int remoteDispatchDomainMigratePrepare3ParamsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePrepare3Params(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigratePrepare3Params body has to be implemented manually */
static int remoteDispatchDomainMigratePrepareTunnel(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare_tunnel_args *args);
static int remoteDispatchDomainMigratePrepareTunnelHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePrepareTunnel(server, client, msg, rerr, args);
}
static int remoteDispatchDomainMigratePrepareTunnel(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare_tunnel_args *args)
{
int rv = -1;
unsigned long flags;
char *dname;
unsigned long resource;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virStreamPtr st = NULL;
daemonClientStreamPtr stream = NULL;
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
HYPER_TO_ULONG(flags, args->flags);
HYPER_TO_ULONG(resource, args->resource);
dname = args->dname ? *args->dname : NULL;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = daemonCreateClientStream(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (virDomainMigratePrepareTunnel(priv->conn, st, flags, dname, resource, args->dom_xml) < 0)
goto cleanup;
if (daemonAddClientStream(client, stream, false) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
if (stream) {
virStreamAbort(st);
daemonFreeClientStream(client, stream);
} else {
virStreamFree(st);
}
}
return rv;
}
static int remoteDispatchDomainMigratePrepareTunnel3(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare_tunnel3_args *args,
remote_domain_migrate_prepare_tunnel3_ret *ret);
static int remoteDispatchDomainMigratePrepareTunnel3Helper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePrepareTunnel3(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainMigratePrepareTunnel3(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare_tunnel3_args *args,
remote_domain_migrate_prepare_tunnel3_ret *ret)
{
int rv = -1;
unsigned long flags;
char *dname;
unsigned long resource;
char *cookie_out = NULL;
int cookie_out_len = 0;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virStreamPtr st = NULL;
daemonClientStreamPtr stream = NULL;
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
HYPER_TO_ULONG(flags, args->flags);
HYPER_TO_ULONG(resource, args->resource);
dname = args->dname ? *args->dname : NULL;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = daemonCreateClientStream(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (virDomainMigratePrepareTunnel3(priv->conn, st, args->cookie_in.cookie_in_val, args->cookie_in.cookie_in_len, &cookie_out, &cookie_out_len, flags, dname, resource, args->dom_xml) < 0)
goto cleanup;
if (daemonAddClientStream(client, stream, false) < 0)
goto cleanup;
ret->cookie_out.cookie_out_val = cookie_out;
ret->cookie_out.cookie_out_len = cookie_out_len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(cookie_out);
if (stream) {
virStreamAbort(st);
daemonFreeClientStream(client, stream);
} else {
virStreamFree(st);
}
}
return rv;
}
static int remoteDispatchDomainMigratePrepareTunnel3Params(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_prepare_tunnel3_params_args *args,
remote_domain_migrate_prepare_tunnel3_params_ret *ret);
static int remoteDispatchDomainMigratePrepareTunnel3ParamsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigratePrepareTunnel3Params(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainMigratePrepareTunnel3Params body has to be implemented manually */
static int remoteDispatchDomainMigrateSetCompressionCache(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_set_compression_cache_args *args);
static int remoteDispatchDomainMigrateSetCompressionCacheHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateSetCompressionCache(server, client, msg, rerr, args);
}
static int remoteDispatchDomainMigrateSetCompressionCache(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_set_compression_cache_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainMigrateSetCompressionCache(dom, args->cacheSize, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainMigrateSetMaxDowntime(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_set_max_downtime_args *args);
static int remoteDispatchDomainMigrateSetMaxDowntimeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateSetMaxDowntime(server, client, msg, rerr, args);
}
static int remoteDispatchDomainMigrateSetMaxDowntime(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_set_max_downtime_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainMigrateSetMaxDowntime(dom, args->downtime, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainMigrateSetMaxSpeed(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_migrate_set_max_speed_args *args);
static int remoteDispatchDomainMigrateSetMaxSpeedHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainMigrateSetMaxSpeed(server, client, msg, rerr, args);
}
static int remoteDispatchDomainMigrateSetMaxSpeed(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_migrate_set_max_speed_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
if (virDomainMigrateSetMaxSpeed(dom, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainOpenChannel(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_open_channel_args *args);
static int remoteDispatchDomainOpenChannelHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainOpenChannel(server, client, msg, rerr, args);
}
static int remoteDispatchDomainOpenChannel(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_open_channel_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *name;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virStreamPtr st = NULL;
daemonClientStreamPtr stream = NULL;
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
name = args->name ? *args->name : NULL;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = daemonCreateClientStream(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (virDomainOpenChannel(dom, name, st, args->flags) < 0)
goto cleanup;
if (daemonAddClientStream(client, stream, true) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
if (stream) {
virStreamAbort(st);
daemonFreeClientStream(client, stream);
} else {
virStreamFree(st);
}
}
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainOpenConsole(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_open_console_args *args);
static int remoteDispatchDomainOpenConsoleHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainOpenConsole(server, client, msg, rerr, args);
}
static int remoteDispatchDomainOpenConsole(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_open_console_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *dev_name;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virStreamPtr st = NULL;
daemonClientStreamPtr stream = NULL;
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
dev_name = args->dev_name ? *args->dev_name : NULL;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = daemonCreateClientStream(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (virDomainOpenConsole(dom, dev_name, st, args->flags) < 0)
goto cleanup;
if (daemonAddClientStream(client, stream, true) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
if (stream) {
virStreamAbort(st);
daemonFreeClientStream(client, stream);
} else {
virStreamFree(st);
}
}
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainOpenGraphics(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_open_graphics_args *args);
static int remoteDispatchDomainOpenGraphicsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainOpenGraphics(server, client, msg, rerr, args);
}
/* remoteDispatchDomainOpenGraphics body has to be implemented manually */
static int remoteDispatchDomainPinEmulator(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_pin_emulator_args *args);
static int remoteDispatchDomainPinEmulatorHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainPinEmulator(server, client, msg, rerr, args);
}
/* remoteDispatchDomainPinEmulator body has to be implemented manually */
static int remoteDispatchDomainPinVcpu(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_pin_vcpu_args *args);
static int remoteDispatchDomainPinVcpuHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainPinVcpu(server, client, msg, rerr, args);
}
static int remoteDispatchDomainPinVcpu(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_pin_vcpu_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainPinVcpu(dom, args->vcpu, (unsigned char *) args->cpumap.cpumap_val, args->cpumap.cpumap_len) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainPinVcpuFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_pin_vcpu_flags_args *args);
static int remoteDispatchDomainPinVcpuFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainPinVcpuFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainPinVcpuFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_pin_vcpu_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainPinVcpuFlags(dom, args->vcpu, (unsigned char *) args->cpumap.cpumap_val, args->cpumap.cpumap_len, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainPMSuspendForDuration(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_pm_suspend_for_duration_args *args);
static int remoteDispatchDomainPMSuspendForDurationHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainPMSuspendForDuration(server, client, msg, rerr, args);
}
static int remoteDispatchDomainPMSuspendForDuration(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_pm_suspend_for_duration_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainPMSuspendForDuration(dom, args->target, args->duration, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainPMWakeup(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_pm_wakeup_args *args);
static int remoteDispatchDomainPMWakeupHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainPMWakeup(server, client, msg, rerr, args);
}
static int remoteDispatchDomainPMWakeup(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_pm_wakeup_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainPMWakeup(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainReboot(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_reboot_args *args);
static int remoteDispatchDomainRebootHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainReboot(server, client, msg, rerr, args);
}
static int remoteDispatchDomainReboot(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_reboot_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainReboot(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainReset(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_reset_args *args);
static int remoteDispatchDomainResetHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainReset(server, client, msg, rerr, args);
}
static int remoteDispatchDomainReset(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_reset_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainReset(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainRestore(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_restore_args *args);
static int remoteDispatchDomainRestoreHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainRestore(server, client, msg, rerr, args);
}
static int remoteDispatchDomainRestore(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_restore_args *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virDomainRestore(priv->conn, args->from) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchDomainRestoreFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_restore_flags_args *args);
static int remoteDispatchDomainRestoreFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainRestoreFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainRestoreFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_restore_flags_args *args)
{
int rv = -1;
char *dxml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
dxml = args->dxml ? *args->dxml : NULL;
if (virDomainRestoreFlags(priv->conn, args->from, dxml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchDomainResume(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_resume_args *args);
static int remoteDispatchDomainResumeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainResume(server, client, msg, rerr, args);
}
static int remoteDispatchDomainResume(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_resume_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainResume(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainRevertToSnapshot(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_revert_to_snapshot_args *args);
static int remoteDispatchDomainRevertToSnapshotHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainRevertToSnapshot(server, client, msg, rerr, args);
}
static int remoteDispatchDomainRevertToSnapshot(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_revert_to_snapshot_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snapshot = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snap)))
goto cleanup;
if (virDomainRevertToSnapshot(snapshot, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (snapshot)
virDomainSnapshotFree(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSave(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_save_args *args);
static int remoteDispatchDomainSaveHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSave(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSave(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_save_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSave(dom, args->to) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSaveFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_save_flags_args *args);
static int remoteDispatchDomainSaveFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSaveFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSaveFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_save_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *dxml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
dxml = args->dxml ? *args->dxml : NULL;
if (virDomainSaveFlags(dom, args->to, dxml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSaveImageDefineXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_save_image_define_xml_args *args);
static int remoteDispatchDomainSaveImageDefineXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSaveImageDefineXML(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSaveImageDefineXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_save_image_define_xml_args *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virDomainSaveImageDefineXML(priv->conn, args->file, args->dxml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchDomainSaveImageGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_save_image_get_xml_desc_args *args,
remote_domain_save_image_get_xml_desc_ret *ret);
static int remoteDispatchDomainSaveImageGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSaveImageGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSaveImageGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_save_image_get_xml_desc_args *args,
remote_domain_save_image_get_xml_desc_ret *ret)
{
int rv = -1;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((xml = virDomainSaveImageGetXMLDesc(priv->conn, args->file, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchDomainScreenshot(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_screenshot_args *args,
remote_domain_screenshot_ret *ret);
static int remoteDispatchDomainScreenshotHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainScreenshot(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainScreenshot(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_screenshot_args *args,
remote_domain_screenshot_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *mime = NULL;
char **mime_p = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virStreamPtr st = NULL;
daemonClientStreamPtr stream = NULL;
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = daemonCreateClientStream(client, st, remoteProgram, &msg->header)))
goto cleanup;
if ((mime = virDomainScreenshot(dom, st, args->screen, args->flags)) == NULL)
goto cleanup;
if (daemonAddClientStream(client, stream, true) < 0)
goto cleanup;
if (VIR_ALLOC(mime_p) < 0)
goto cleanup;
if (VIR_STRDUP(*mime_p, mime) < 0)
goto cleanup;
ret->mime = mime_p;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(mime_p);
if (stream) {
virStreamAbort(st);
daemonFreeClientStream(client, stream);
} else {
virStreamFree(st);
}
}
if (dom)
virDomainFree(dom);
VIR_FREE(mime);
return rv;
}
static int remoteDispatchDomainSendKey(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_send_key_args *args);
static int remoteDispatchDomainSendKeyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSendKey(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSendKey(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_send_key_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSendKey(dom, args->codeset, args->holdtime, args->keycodes.keycodes_val, args->keycodes.keycodes_len, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSendProcessSignal(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_send_process_signal_args *args);
static int remoteDispatchDomainSendProcessSignalHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSendProcessSignal(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSendProcessSignal(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_send_process_signal_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSendProcessSignal(dom, args->pid_value, args->signum, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSetAutostart(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_autostart_args *args);
static int remoteDispatchDomainSetAutostartHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetAutostart(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetAutostart(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_autostart_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSetAutostart(dom, args->autostart) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSetBlkioParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_blkio_parameters_args *args);
static int remoteDispatchDomainSetBlkioParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetBlkioParameters(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetBlkioParameters(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_blkio_parameters_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = remoteDeserializeTypedParameters(args->params.params_val,
args->params.params_len,
REMOTE_DOMAIN_BLKIO_PARAMETERS_MAX,
&nparams)) == NULL)
goto cleanup;
if (virDomainSetBlkioParameters(dom, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int remoteDispatchDomainSetBlockIoTune(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_block_io_tune_args *args);
static int remoteDispatchDomainSetBlockIoTuneHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetBlockIoTune(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetBlockIoTune(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_block_io_tune_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = remoteDeserializeTypedParameters(args->params.params_val,
args->params.params_len,
REMOTE_DOMAIN_BLOCK_IO_TUNE_PARAMETERS_MAX,
&nparams)) == NULL)
goto cleanup;
if (virDomainSetBlockIoTune(dom, args->disk, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int remoteDispatchDomainSetInterfaceParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_interface_parameters_args *args);
static int remoteDispatchDomainSetInterfaceParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetInterfaceParameters(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetInterfaceParameters(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_interface_parameters_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = remoteDeserializeTypedParameters(args->params.params_val,
args->params.params_len,
REMOTE_DOMAIN_INTERFACE_PARAMETERS_MAX,
&nparams)) == NULL)
goto cleanup;
if (virDomainSetInterfaceParameters(dom, args->device, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int remoteDispatchDomainSetMaxMemory(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_max_memory_args *args);
static int remoteDispatchDomainSetMaxMemoryHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetMaxMemory(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetMaxMemory(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_max_memory_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long memory;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(memory, args->memory);
if (virDomainSetMaxMemory(dom, memory) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSetMemory(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_memory_args *args);
static int remoteDispatchDomainSetMemoryHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetMemory(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetMemory(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_memory_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long memory;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(memory, args->memory);
if (virDomainSetMemory(dom, memory) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSetMemoryFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_memory_flags_args *args);
static int remoteDispatchDomainSetMemoryFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetMemoryFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetMemoryFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_memory_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long memory;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(memory, args->memory);
if (virDomainSetMemoryFlags(dom, memory, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSetMemoryParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_memory_parameters_args *args);
static int remoteDispatchDomainSetMemoryParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetMemoryParameters(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetMemoryParameters(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_memory_parameters_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = remoteDeserializeTypedParameters(args->params.params_val,
args->params.params_len,
REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX,
&nparams)) == NULL)
goto cleanup;
if (virDomainSetMemoryParameters(dom, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int remoteDispatchDomainSetMemoryStatsPeriod(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_memory_stats_period_args *args);
static int remoteDispatchDomainSetMemoryStatsPeriodHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetMemoryStatsPeriod(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetMemoryStatsPeriod(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_memory_stats_period_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSetMemoryStatsPeriod(dom, args->period, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSetMetadata(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_metadata_args *args);
static int remoteDispatchDomainSetMetadataHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetMetadata(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetMetadata(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_metadata_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *metadata;
char *key;
char *uri;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
metadata = args->metadata ? *args->metadata : NULL;
key = args->key ? *args->key : NULL;
uri = args->uri ? *args->uri : NULL;
if (virDomainSetMetadata(dom, args->type, metadata, key, uri, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSetNumaParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_numa_parameters_args *args);
static int remoteDispatchDomainSetNumaParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetNumaParameters(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetNumaParameters(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_numa_parameters_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = remoteDeserializeTypedParameters(args->params.params_val,
args->params.params_len,
REMOTE_DOMAIN_NUMA_PARAMETERS_MAX,
&nparams)) == NULL)
goto cleanup;
if (virDomainSetNumaParameters(dom, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int remoteDispatchDomainSetSchedulerParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_scheduler_parameters_args *args);
static int remoteDispatchDomainSetSchedulerParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetSchedulerParameters(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetSchedulerParameters(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_scheduler_parameters_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = remoteDeserializeTypedParameters(args->params.params_val,
args->params.params_len,
REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX,
&nparams)) == NULL)
goto cleanup;
if (virDomainSetSchedulerParameters(dom, params, nparams) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int remoteDispatchDomainSetSchedulerParametersFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_scheduler_parameters_flags_args *args);
static int remoteDispatchDomainSetSchedulerParametersFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetSchedulerParametersFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetSchedulerParametersFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_scheduler_parameters_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = remoteDeserializeTypedParameters(args->params.params_val,
args->params.params_len,
REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX,
&nparams)) == NULL)
goto cleanup;
if (virDomainSetSchedulerParametersFlags(dom, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int remoteDispatchDomainSetVcpus(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_vcpus_args *args);
static int remoteDispatchDomainSetVcpusHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetVcpus(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetVcpus(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_vcpus_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSetVcpus(dom, args->nvcpus) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSetVcpusFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_set_vcpus_flags_args *args);
static int remoteDispatchDomainSetVcpusFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSetVcpusFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSetVcpusFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_set_vcpus_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSetVcpusFlags(dom, args->nvcpus, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainShutdown(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_shutdown_args *args);
static int remoteDispatchDomainShutdownHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainShutdown(server, client, msg, rerr, args);
}
static int remoteDispatchDomainShutdown(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_shutdown_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainShutdown(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainShutdownFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_shutdown_flags_args *args);
static int remoteDispatchDomainShutdownFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainShutdownFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainShutdownFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_shutdown_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainShutdownFlags(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSnapshotCreateXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_create_xml_args *args,
remote_domain_snapshot_create_xml_ret *ret);
static int remoteDispatchDomainSnapshotCreateXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotCreateXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotCreateXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_create_xml_args *args,
remote_domain_snapshot_create_xml_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snap = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((snap = virDomainSnapshotCreateXML(dom, args->xml_desc, args->flags)) == NULL)
goto cleanup;
make_nonnull_domain_snapshot(&ret->snap, snap);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
if (snap)
virDomainSnapshotFree(snap);
return rv;
}
static int remoteDispatchDomainSnapshotCurrent(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_current_args *args,
remote_domain_snapshot_current_ret *ret);
static int remoteDispatchDomainSnapshotCurrentHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotCurrent(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotCurrent(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_current_args *args,
remote_domain_snapshot_current_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snap = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((snap = virDomainSnapshotCurrent(dom, args->flags)) == NULL)
goto cleanup;
make_nonnull_domain_snapshot(&ret->snap, snap);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
if (snap)
virDomainSnapshotFree(snap);
return rv;
}
static int remoteDispatchDomainSnapshotDelete(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_delete_args *args);
static int remoteDispatchDomainSnapshotDeleteHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotDelete(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSnapshotDelete(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_delete_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snapshot = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snap)))
goto cleanup;
if (virDomainSnapshotDelete(snapshot, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (snapshot)
virDomainSnapshotFree(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSnapshotGetParent(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_get_parent_args *args,
remote_domain_snapshot_get_parent_ret *ret);
static int remoteDispatchDomainSnapshotGetParentHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotGetParent(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotGetParent(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_get_parent_args *args,
remote_domain_snapshot_get_parent_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snapshot = NULL;
virDomainSnapshotPtr snap = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snap)))
goto cleanup;
if ((snap = virDomainSnapshotGetParent(snapshot, args->flags)) == NULL)
goto cleanup;
make_nonnull_domain_snapshot(&ret->snap, snap);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (snapshot)
virDomainSnapshotFree(snapshot);
if (dom)
virDomainFree(dom);
if (snap)
virDomainSnapshotFree(snap);
return rv;
}
static int remoteDispatchDomainSnapshotGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_get_xml_desc_args *args,
remote_domain_snapshot_get_xml_desc_ret *ret);
static int remoteDispatchDomainSnapshotGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_get_xml_desc_args *args,
remote_domain_snapshot_get_xml_desc_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snapshot = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snap)))
goto cleanup;
if ((xml = virDomainSnapshotGetXMLDesc(snapshot, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (snapshot)
virDomainSnapshotFree(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSnapshotHasMetadata(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_has_metadata_args *args,
remote_domain_snapshot_has_metadata_ret *ret);
static int remoteDispatchDomainSnapshotHasMetadataHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotHasMetadata(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotHasMetadata(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_has_metadata_args *args,
remote_domain_snapshot_has_metadata_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snapshot = NULL;
int metadata;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snap)))
goto cleanup;
if ((metadata = virDomainSnapshotHasMetadata(snapshot, args->flags)) < 0)
goto cleanup;
ret->metadata = metadata;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (snapshot)
virDomainSnapshotFree(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSnapshotIsCurrent(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_is_current_args *args,
remote_domain_snapshot_is_current_ret *ret);
static int remoteDispatchDomainSnapshotIsCurrentHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotIsCurrent(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotIsCurrent(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_is_current_args *args,
remote_domain_snapshot_is_current_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snapshot = NULL;
int current;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snap)))
goto cleanup;
if ((current = virDomainSnapshotIsCurrent(snapshot, args->flags)) < 0)
goto cleanup;
ret->current = current;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (snapshot)
virDomainSnapshotFree(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSnapshotListAllChildren(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_list_all_children_args *args,
remote_domain_snapshot_list_all_children_ret *ret);
static int remoteDispatchDomainSnapshotListAllChildrenHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotListAllChildren(server, client, msg, rerr, args, ret);
}
/* remoteDispatchDomainSnapshotListAllChildren body has to be implemented manually */
static int remoteDispatchDomainSnapshotListChildrenNames(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_list_children_names_args *args,
remote_domain_snapshot_list_children_names_ret *ret);
static int remoteDispatchDomainSnapshotListChildrenNamesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotListChildrenNames(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotListChildrenNames(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_list_children_names_args *args,
remote_domain_snapshot_list_children_names_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snapshot = NULL;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_DOMAIN_SNAPSHOT_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_DOMAIN_SNAPSHOT_LIST_MAX"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snap)))
goto cleanup;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virDomainSnapshotListChildrenNames(snapshot, ret->names.names_val, args->maxnames, args->flags)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
if (snapshot)
virDomainSnapshotFree(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSnapshotListNames(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_list_names_args *args,
remote_domain_snapshot_list_names_ret *ret);
static int remoteDispatchDomainSnapshotListNamesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotListNames(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotListNames(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_list_names_args *args,
remote_domain_snapshot_list_names_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_DOMAIN_SNAPSHOT_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_DOMAIN_SNAPSHOT_LIST_MAX"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virDomainSnapshotListNames(dom, ret->names.names_val, args->maxnames, args->flags)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSnapshotLookupByName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_lookup_by_name_args *args,
remote_domain_snapshot_lookup_by_name_ret *ret);
static int remoteDispatchDomainSnapshotLookupByNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotLookupByName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotLookupByName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_lookup_by_name_args *args,
remote_domain_snapshot_lookup_by_name_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snap = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((snap = virDomainSnapshotLookupByName(dom, args->name, args->flags)) == NULL)
goto cleanup;
make_nonnull_domain_snapshot(&ret->snap, snap);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
if (snap)
virDomainSnapshotFree(snap);
return rv;
}
static int remoteDispatchDomainSnapshotNum(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_num_args *args,
remote_domain_snapshot_num_ret *ret);
static int remoteDispatchDomainSnapshotNumHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotNum(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotNum(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_num_args *args,
remote_domain_snapshot_num_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((num = virDomainSnapshotNum(dom, args->flags)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSnapshotNumChildren(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_num_children_args *args,
remote_domain_snapshot_num_children_ret *ret);
static int remoteDispatchDomainSnapshotNumChildrenHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSnapshotNumChildren(server, client, msg, rerr, args, ret);
}
static int remoteDispatchDomainSnapshotNumChildren(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_snapshot_num_children_args *args,
remote_domain_snapshot_num_children_ret *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainSnapshotPtr snapshot = NULL;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snap)))
goto cleanup;
if ((num = virDomainSnapshotNumChildren(snapshot, args->flags)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (snapshot)
virDomainSnapshotFree(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainSuspend(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_suspend_args *args);
static int remoteDispatchDomainSuspendHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainSuspend(server, client, msg, rerr, args);
}
static int remoteDispatchDomainSuspend(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_suspend_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSuspend(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainUndefine(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_undefine_args *args);
static int remoteDispatchDomainUndefineHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainUndefine(server, client, msg, rerr, args);
}
static int remoteDispatchDomainUndefine(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_undefine_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainUndefine(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainUndefineFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_undefine_flags_args *args);
static int remoteDispatchDomainUndefineFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainUndefineFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainUndefineFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_undefine_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainUndefineFlags(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchDomainUpdateDeviceFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_domain_update_device_flags_args *args);
static int remoteDispatchDomainUpdateDeviceFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchDomainUpdateDeviceFlags(server, client, msg, rerr, args);
}
static int remoteDispatchDomainUpdateDeviceFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_domain_update_device_flags_args *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainUpdateDeviceFlags(dom, args->xml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int remoteDispatchInterfaceChangeBegin(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_change_begin_args *args);
static int remoteDispatchInterfaceChangeBeginHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceChangeBegin(server, client, msg, rerr, args);
}
static int remoteDispatchInterfaceChangeBegin(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_change_begin_args *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virInterfaceChangeBegin(priv->conn, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchInterfaceChangeCommit(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_change_commit_args *args);
static int remoteDispatchInterfaceChangeCommitHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceChangeCommit(server, client, msg, rerr, args);
}
static int remoteDispatchInterfaceChangeCommit(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_change_commit_args *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virInterfaceChangeCommit(priv->conn, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchInterfaceChangeRollback(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_change_rollback_args *args);
static int remoteDispatchInterfaceChangeRollbackHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceChangeRollback(server, client, msg, rerr, args);
}
static int remoteDispatchInterfaceChangeRollback(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_change_rollback_args *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virInterfaceChangeRollback(priv->conn, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchInterfaceCreate(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_create_args *args);
static int remoteDispatchInterfaceCreateHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceCreate(server, client, msg, rerr, args);
}
static int remoteDispatchInterfaceCreate(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_create_args *args)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = get_nonnull_interface(priv->conn, args->iface)))
goto cleanup;
if (virInterfaceCreate(iface, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int remoteDispatchInterfaceDefineXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_define_xml_args *args,
remote_interface_define_xml_ret *ret);
static int remoteDispatchInterfaceDefineXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceDefineXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchInterfaceDefineXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_define_xml_args *args,
remote_interface_define_xml_ret *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((iface = virInterfaceDefineXML(priv->conn, args->xml, args->flags)) == NULL)
goto cleanup;
make_nonnull_interface(&ret->iface, iface);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int remoteDispatchInterfaceDestroy(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_destroy_args *args);
static int remoteDispatchInterfaceDestroyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceDestroy(server, client, msg, rerr, args);
}
static int remoteDispatchInterfaceDestroy(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_destroy_args *args)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = get_nonnull_interface(priv->conn, args->iface)))
goto cleanup;
if (virInterfaceDestroy(iface, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int remoteDispatchInterfaceGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_get_xml_desc_args *args,
remote_interface_get_xml_desc_ret *ret);
static int remoteDispatchInterfaceGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchInterfaceGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_get_xml_desc_args *args,
remote_interface_get_xml_desc_ret *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = get_nonnull_interface(priv->conn, args->iface)))
goto cleanup;
if ((xml = virInterfaceGetXMLDesc(iface, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int remoteDispatchInterfaceIsActive(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_is_active_args *args,
remote_interface_is_active_ret *ret);
static int remoteDispatchInterfaceIsActiveHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceIsActive(server, client, msg, rerr, args, ret);
}
static int remoteDispatchInterfaceIsActive(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_is_active_args *args,
remote_interface_is_active_ret *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
int active;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = get_nonnull_interface(priv->conn, args->iface)))
goto cleanup;
if ((active = virInterfaceIsActive(iface)) < 0)
goto cleanup;
ret->active = active;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int remoteDispatchInterfaceLookupByMACString(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_lookup_by_mac_string_args *args,
remote_interface_lookup_by_mac_string_ret *ret);
static int remoteDispatchInterfaceLookupByMACStringHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceLookupByMACString(server, client, msg, rerr, args, ret);
}
static int remoteDispatchInterfaceLookupByMACString(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_lookup_by_mac_string_args *args,
remote_interface_lookup_by_mac_string_ret *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((iface = virInterfaceLookupByMACString(priv->conn, args->mac)) == NULL)
goto cleanup;
make_nonnull_interface(&ret->iface, iface);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int remoteDispatchInterfaceLookupByName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_lookup_by_name_args *args,
remote_interface_lookup_by_name_ret *ret);
static int remoteDispatchInterfaceLookupByNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceLookupByName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchInterfaceLookupByName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_lookup_by_name_args *args,
remote_interface_lookup_by_name_ret *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((iface = virInterfaceLookupByName(priv->conn, args->name)) == NULL)
goto cleanup;
make_nonnull_interface(&ret->iface, iface);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int remoteDispatchInterfaceUndefine(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_interface_undefine_args *args);
static int remoteDispatchInterfaceUndefineHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchInterfaceUndefine(server, client, msg, rerr, args);
}
static int remoteDispatchInterfaceUndefine(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_interface_undefine_args *args)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = get_nonnull_interface(priv->conn, args->iface)))
goto cleanup;
if (virInterfaceUndefine(iface) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int remoteDispatchNetworkCreate(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_create_args *args);
static int remoteDispatchNetworkCreateHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkCreate(server, client, msg, rerr, args);
}
static int remoteDispatchNetworkCreate(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_create_args *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkCreate(net) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkCreateXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_create_xml_args *args,
remote_network_create_xml_ret *ret);
static int remoteDispatchNetworkCreateXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkCreateXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkCreateXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_create_xml_args *args,
remote_network_create_xml_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((net = virNetworkCreateXML(priv->conn, args->xml)) == NULL)
goto cleanup;
make_nonnull_network(&ret->net, net);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkDefineXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_define_xml_args *args,
remote_network_define_xml_ret *ret);
static int remoteDispatchNetworkDefineXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkDefineXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkDefineXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_define_xml_args *args,
remote_network_define_xml_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((net = virNetworkDefineXML(priv->conn, args->xml)) == NULL)
goto cleanup;
make_nonnull_network(&ret->net, net);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkDestroy(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_destroy_args *args);
static int remoteDispatchNetworkDestroyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkDestroy(server, client, msg, rerr, args);
}
static int remoteDispatchNetworkDestroy(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_destroy_args *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkDestroy(net) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkGetAutostart(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_get_autostart_args *args,
remote_network_get_autostart_ret *ret);
static int remoteDispatchNetworkGetAutostartHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkGetAutostart(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkGetAutostart(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_get_autostart_args *args,
remote_network_get_autostart_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
int autostart;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkGetAutostart(net, &autostart) < 0)
goto cleanup;
ret->autostart = autostart;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkGetBridgeName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_get_bridge_name_args *args,
remote_network_get_bridge_name_ret *ret);
static int remoteDispatchNetworkGetBridgeNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkGetBridgeName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkGetBridgeName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_get_bridge_name_args *args,
remote_network_get_bridge_name_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
char *name;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if ((name = virNetworkGetBridgeName(net)) == NULL)
goto cleanup;
ret->name = name;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_get_xml_desc_args *args,
remote_network_get_xml_desc_ret *ret);
static int remoteDispatchNetworkGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_get_xml_desc_args *args,
remote_network_get_xml_desc_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if ((xml = virNetworkGetXMLDesc(net, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkIsActive(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_is_active_args *args,
remote_network_is_active_ret *ret);
static int remoteDispatchNetworkIsActiveHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkIsActive(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkIsActive(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_is_active_args *args,
remote_network_is_active_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
int active;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if ((active = virNetworkIsActive(net)) < 0)
goto cleanup;
ret->active = active;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkIsPersistent(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_is_persistent_args *args,
remote_network_is_persistent_ret *ret);
static int remoteDispatchNetworkIsPersistentHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkIsPersistent(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkIsPersistent(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_is_persistent_args *args,
remote_network_is_persistent_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
int persistent;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if ((persistent = virNetworkIsPersistent(net)) < 0)
goto cleanup;
ret->persistent = persistent;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkLookupByName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_lookup_by_name_args *args,
remote_network_lookup_by_name_ret *ret);
static int remoteDispatchNetworkLookupByNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkLookupByName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkLookupByName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_lookup_by_name_args *args,
remote_network_lookup_by_name_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((net = virNetworkLookupByName(priv->conn, args->name)) == NULL)
goto cleanup;
make_nonnull_network(&ret->net, net);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkLookupByUUID(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_lookup_by_uuid_args *args,
remote_network_lookup_by_uuid_ret *ret);
static int remoteDispatchNetworkLookupByUUIDHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkLookupByUUID(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNetworkLookupByUUID(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_lookup_by_uuid_args *args,
remote_network_lookup_by_uuid_ret *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((net = virNetworkLookupByUUID(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
make_nonnull_network(&ret->net, net);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkSetAutostart(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_set_autostart_args *args);
static int remoteDispatchNetworkSetAutostartHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkSetAutostart(server, client, msg, rerr, args);
}
static int remoteDispatchNetworkSetAutostart(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_set_autostart_args *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkSetAutostart(net, args->autostart) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkUndefine(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_undefine_args *args);
static int remoteDispatchNetworkUndefineHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkUndefine(server, client, msg, rerr, args);
}
static int remoteDispatchNetworkUndefine(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_undefine_args *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkUndefine(net) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNetworkUpdate(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_network_update_args *args);
static int remoteDispatchNetworkUpdateHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNetworkUpdate(server, client, msg, rerr, args);
}
static int remoteDispatchNetworkUpdate(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_network_update_args *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkUpdate(net, args->command, args->section, args->parentIndex, args->xml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int remoteDispatchNodeDeviceCreateXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_create_xml_args *args,
remote_node_device_create_xml_ret *ret);
static int remoteDispatchNodeDeviceCreateXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceCreateXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeDeviceCreateXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_create_xml_args *args,
remote_node_device_create_xml_ret *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((dev = virNodeDeviceCreateXML(priv->conn, args->xml_desc, args->flags)) == NULL)
goto cleanup;
make_nonnull_node_device(&ret->dev, dev);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceDestroy(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_destroy_args *args);
static int remoteDispatchNodeDeviceDestroyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceDestroy(server, client, msg, rerr, args);
}
static int remoteDispatchNodeDeviceDestroy(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_destroy_args *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
goto cleanup;
if (virNodeDeviceDestroy(dev) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceDetachFlags(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_detach_flags_args *args);
static int remoteDispatchNodeDeviceDetachFlagsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceDetachFlags(server, client, msg, rerr, args);
}
static int remoteDispatchNodeDeviceDetachFlags(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_detach_flags_args *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
char *driverName;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
goto cleanup;
driverName = args->driverName ? *args->driverName : NULL;
if (virNodeDeviceDetachFlags(dev, driverName, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceDettach(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_dettach_args *args);
static int remoteDispatchNodeDeviceDettachHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceDettach(server, client, msg, rerr, args);
}
static int remoteDispatchNodeDeviceDettach(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_dettach_args *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
goto cleanup;
if (virNodeDeviceDettach(dev) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceGetParent(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_get_parent_args *args,
remote_node_device_get_parent_ret *ret);
static int remoteDispatchNodeDeviceGetParentHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceGetParent(server, client, msg, rerr, args, ret);
}
/* remoteDispatchNodeDeviceGetParent body has to be implemented manually */
static int remoteDispatchNodeDeviceGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_get_xml_desc_args *args,
remote_node_device_get_xml_desc_ret *ret);
static int remoteDispatchNodeDeviceGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeDeviceGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_get_xml_desc_args *args,
remote_node_device_get_xml_desc_ret *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
goto cleanup;
if ((xml = virNodeDeviceGetXMLDesc(dev, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceListCaps(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_list_caps_args *args,
remote_node_device_list_caps_ret *ret);
static int remoteDispatchNodeDeviceListCapsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceListCaps(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeDeviceListCaps(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_list_caps_args *args,
remote_node_device_list_caps_ret *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_NODE_DEVICE_CAPS_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_NODE_DEVICE_CAPS_LIST_MAX"));
goto cleanup;
}
if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
goto cleanup;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virNodeDeviceListCaps(dev, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceLookupByName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_lookup_by_name_args *args,
remote_node_device_lookup_by_name_ret *ret);
static int remoteDispatchNodeDeviceLookupByNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceLookupByName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeDeviceLookupByName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_lookup_by_name_args *args,
remote_node_device_lookup_by_name_ret *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((dev = virNodeDeviceLookupByName(priv->conn, args->name)) == NULL)
goto cleanup;
make_nonnull_node_device(&ret->dev, dev);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceLookupSCSIHostByWWN(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_lookup_scsi_host_by_wwn_args *args,
remote_node_device_lookup_scsi_host_by_wwn_ret *ret);
static int remoteDispatchNodeDeviceLookupSCSIHostByWWNHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceLookupSCSIHostByWWN(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeDeviceLookupSCSIHostByWWN(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_lookup_scsi_host_by_wwn_args *args,
remote_node_device_lookup_scsi_host_by_wwn_ret *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((dev = virNodeDeviceLookupSCSIHostByWWN(priv->conn, args->wwnn, args->wwpn, args->flags)) == NULL)
goto cleanup;
make_nonnull_node_device(&ret->dev, dev);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceNumOfCaps(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_num_of_caps_args *args,
remote_node_device_num_of_caps_ret *ret);
static int remoteDispatchNodeDeviceNumOfCapsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceNumOfCaps(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeDeviceNumOfCaps(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_num_of_caps_args *args,
remote_node_device_num_of_caps_ret *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
goto cleanup;
if ((num = virNodeDeviceNumOfCaps(dev)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceReAttach(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_re_attach_args *args);
static int remoteDispatchNodeDeviceReAttachHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceReAttach(server, client, msg, rerr, args);
}
static int remoteDispatchNodeDeviceReAttach(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_re_attach_args *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
goto cleanup;
if (virNodeDeviceReAttach(dev) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeDeviceReset(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_device_reset_args *args);
static int remoteDispatchNodeDeviceResetHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeDeviceReset(server, client, msg, rerr, args);
}
static int remoteDispatchNodeDeviceReset(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_device_reset_args *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
goto cleanup;
if (virNodeDeviceReset(dev) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int remoteDispatchNodeGetCellsFreeMemory(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_get_cells_free_memory_args *args,
remote_node_get_cells_free_memory_ret *ret);
static int remoteDispatchNodeGetCellsFreeMemoryHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeGetCellsFreeMemory(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeGetCellsFreeMemory(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_get_cells_free_memory_args *args,
remote_node_get_cells_free_memory_ret *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxcells > REMOTE_NODE_MAX_CELLS) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxcells > REMOTE_NODE_MAX_CELLS"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->cells.cells_val, args->maxcells) < 0)
goto cleanup;
if ((len = virNodeGetCellsFreeMemory(priv->conn, (unsigned long long *)ret->cells.cells_val, args->startCell, args->maxcells)) <= 0)
goto cleanup;
ret->cells.cells_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->cells.cells_val);
}
return rv;
}
static int remoteDispatchNodeGetCPUMap(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_get_cpu_map_args *args,
remote_node_get_cpu_map_ret *ret);
static int remoteDispatchNodeGetCPUMapHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeGetCPUMap(server, client, msg, rerr, args, ret);
}
/* remoteDispatchNodeGetCPUMap body has to be implemented manually */
static int remoteDispatchNodeGetCPUStats(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_get_cpu_stats_args *args,
remote_node_get_cpu_stats_ret *ret);
static int remoteDispatchNodeGetCPUStatsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeGetCPUStats(server, client, msg, rerr, args, ret);
}
/* remoteDispatchNodeGetCPUStats body has to be implemented manually */
static int remoteDispatchNodeGetFreeMemory(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_get_free_memory_ret *ret);
static int remoteDispatchNodeGetFreeMemoryHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeGetFreeMemory(server, client, msg, rerr, ret);
}
static int remoteDispatchNodeGetFreeMemory(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_get_free_memory_ret *ret)
{
int rv = -1;
unsigned long long freeMem;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((freeMem = virNodeGetFreeMemory(priv->conn)) == 0)
goto cleanup;
ret->freeMem = freeMem;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchNodeGetInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_get_info_ret *ret);
static int remoteDispatchNodeGetInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeGetInfo(server, client, msg, rerr, ret);
}
static int remoteDispatchNodeGetInfo(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_get_info_ret *ret)
{
int rv = -1;
virNodeInfo tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virNodeGetInfo(priv->conn, &tmp) < 0)
goto cleanup;
memcpy(ret->model, tmp.model, sizeof(ret->model));
ret->memory = tmp.memory;
ret->cpus = tmp.cpus;
ret->mhz = tmp.mhz;
ret->nodes = tmp.nodes;
ret->sockets = tmp.sockets;
ret->cores = tmp.cores;
ret->threads = tmp.threads;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchNodeGetMemoryParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_get_memory_parameters_args *args,
remote_node_get_memory_parameters_ret *ret);
static int remoteDispatchNodeGetMemoryParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeGetMemoryParameters(server, client, msg, rerr, args, ret);
}
/* remoteDispatchNodeGetMemoryParameters body has to be implemented manually */
static int remoteDispatchNodeGetMemoryStats(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_get_memory_stats_args *args,
remote_node_get_memory_stats_ret *ret);
static int remoteDispatchNodeGetMemoryStatsHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeGetMemoryStats(server, client, msg, rerr, args, ret);
}
/* remoteDispatchNodeGetMemoryStats body has to be implemented manually */
static int remoteDispatchNodeGetSecurityModel(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_get_security_model_ret *ret);
static int remoteDispatchNodeGetSecurityModelHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeGetSecurityModel(server, client, msg, rerr, ret);
}
/* remoteDispatchNodeGetSecurityModel body has to be implemented manually */
static int remoteDispatchNodeListDevices(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_list_devices_args *args,
remote_node_list_devices_ret *ret);
static int remoteDispatchNodeListDevicesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeListDevices(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeListDevices(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_list_devices_args *args,
remote_node_list_devices_ret *ret)
{
int rv = -1;
char *cap;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_NODE_DEVICE_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_NODE_DEVICE_LIST_MAX"));
goto cleanup;
}
cap = args->cap ? *args->cap : NULL;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virNodeListDevices(priv->conn, cap, ret->names.names_val, args->maxnames, args->flags)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int remoteDispatchNodeNumOfDevices(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_num_of_devices_args *args,
remote_node_num_of_devices_ret *ret);
static int remoteDispatchNodeNumOfDevicesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeNumOfDevices(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNodeNumOfDevices(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_num_of_devices_args *args,
remote_node_num_of_devices_ret *ret)
{
int rv = -1;
char *cap;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
cap = args->cap ? *args->cap : NULL;
if ((num = virNodeNumOfDevices(priv->conn, cap, args->flags)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchNodeSetMemoryParameters(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_set_memory_parameters_args *args);
static int remoteDispatchNodeSetMemoryParametersHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeSetMemoryParameters(server, client, msg, rerr, args);
}
static int remoteDispatchNodeSetMemoryParameters(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_set_memory_parameters_args *args)
{
int rv = -1;
virTypedParameterPtr params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((params = remoteDeserializeTypedParameters(args->params.params_val,
args->params.params_len,
REMOTE_NODE_MEMORY_PARAMETERS_MAX,
&nparams)) == NULL)
goto cleanup;
if (virNodeSetMemoryParameters(priv->conn, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
virTypedParamsFree(params, nparams);
return rv;
}
static int remoteDispatchNodeSuspendForDuration(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_node_suspend_for_duration_args *args);
static int remoteDispatchNodeSuspendForDurationHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNodeSuspendForDuration(server, client, msg, rerr, args);
}
static int remoteDispatchNodeSuspendForDuration(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_node_suspend_for_duration_args *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (virNodeSuspendForDuration(priv->conn, args->target, args->duration, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
return rv;
}
static int remoteDispatchNWFilterDefineXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_nwfilter_define_xml_args *args,
remote_nwfilter_define_xml_ret *ret);
static int remoteDispatchNWFilterDefineXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNWFilterDefineXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNWFilterDefineXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_nwfilter_define_xml_args *args,
remote_nwfilter_define_xml_ret *ret)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((nwfilter = virNWFilterDefineXML(priv->conn, args->xml)) == NULL)
goto cleanup;
make_nonnull_nwfilter(&ret->nwfilter, nwfilter);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int remoteDispatchNWFilterGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_nwfilter_get_xml_desc_args *args,
remote_nwfilter_get_xml_desc_ret *ret);
static int remoteDispatchNWFilterGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNWFilterGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNWFilterGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_nwfilter_get_xml_desc_args *args,
remote_nwfilter_get_xml_desc_ret *ret)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(nwfilter = get_nonnull_nwfilter(priv->conn, args->nwfilter)))
goto cleanup;
if ((xml = virNWFilterGetXMLDesc(nwfilter, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int remoteDispatchNWFilterLookupByName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_nwfilter_lookup_by_name_args *args,
remote_nwfilter_lookup_by_name_ret *ret);
static int remoteDispatchNWFilterLookupByNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNWFilterLookupByName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNWFilterLookupByName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_nwfilter_lookup_by_name_args *args,
remote_nwfilter_lookup_by_name_ret *ret)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((nwfilter = virNWFilterLookupByName(priv->conn, args->name)) == NULL)
goto cleanup;
make_nonnull_nwfilter(&ret->nwfilter, nwfilter);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int remoteDispatchNWFilterLookupByUUID(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_nwfilter_lookup_by_uuid_args *args,
remote_nwfilter_lookup_by_uuid_ret *ret);
static int remoteDispatchNWFilterLookupByUUIDHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNWFilterLookupByUUID(server, client, msg, rerr, args, ret);
}
static int remoteDispatchNWFilterLookupByUUID(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_nwfilter_lookup_by_uuid_args *args,
remote_nwfilter_lookup_by_uuid_ret *ret)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((nwfilter = virNWFilterLookupByUUID(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
make_nonnull_nwfilter(&ret->nwfilter, nwfilter);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int remoteDispatchNWFilterUndefine(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_nwfilter_undefine_args *args);
static int remoteDispatchNWFilterUndefineHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchNWFilterUndefine(server, client, msg, rerr, args);
}
static int remoteDispatchNWFilterUndefine(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_nwfilter_undefine_args *args)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(nwfilter = get_nonnull_nwfilter(priv->conn, args->nwfilter)))
goto cleanup;
if (virNWFilterUndefine(nwfilter) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int remoteDispatchSecretDefineXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_secret_define_xml_args *args,
remote_secret_define_xml_ret *ret);
static int remoteDispatchSecretDefineXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchSecretDefineXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchSecretDefineXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_secret_define_xml_args *args,
remote_secret_define_xml_ret *ret)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((secret = virSecretDefineXML(priv->conn, args->xml, args->flags)) == NULL)
goto cleanup;
make_nonnull_secret(&ret->secret, secret);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int remoteDispatchSecretGetValue(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_secret_get_value_args *args,
remote_secret_get_value_ret *ret);
static int remoteDispatchSecretGetValueHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchSecretGetValue(server, client, msg, rerr, args, ret);
}
/* remoteDispatchSecretGetValue body has to be implemented manually */
static int remoteDispatchSecretGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_secret_get_xml_desc_args *args,
remote_secret_get_xml_desc_ret *ret);
static int remoteDispatchSecretGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchSecretGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchSecretGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_secret_get_xml_desc_args *args,
remote_secret_get_xml_desc_ret *ret)
{
int rv = -1;
virSecretPtr secret = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(secret = get_nonnull_secret(priv->conn, args->secret)))
goto cleanup;
if ((xml = virSecretGetXMLDesc(secret, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int remoteDispatchSecretLookupByUsage(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_secret_lookup_by_usage_args *args,
remote_secret_lookup_by_usage_ret *ret);
static int remoteDispatchSecretLookupByUsageHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchSecretLookupByUsage(server, client, msg, rerr, args, ret);
}
static int remoteDispatchSecretLookupByUsage(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_secret_lookup_by_usage_args *args,
remote_secret_lookup_by_usage_ret *ret)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((secret = virSecretLookupByUsage(priv->conn, args->usageType, args->usageID)) == NULL)
goto cleanup;
make_nonnull_secret(&ret->secret, secret);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int remoteDispatchSecretLookupByUUID(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_secret_lookup_by_uuid_args *args,
remote_secret_lookup_by_uuid_ret *ret);
static int remoteDispatchSecretLookupByUUIDHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchSecretLookupByUUID(server, client, msg, rerr, args, ret);
}
static int remoteDispatchSecretLookupByUUID(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_secret_lookup_by_uuid_args *args,
remote_secret_lookup_by_uuid_ret *ret)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((secret = virSecretLookupByUUID(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
make_nonnull_secret(&ret->secret, secret);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int remoteDispatchSecretSetValue(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_secret_set_value_args *args);
static int remoteDispatchSecretSetValueHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchSecretSetValue(server, client, msg, rerr, args);
}
static int remoteDispatchSecretSetValue(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_secret_set_value_args *args)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(secret = get_nonnull_secret(priv->conn, args->secret)))
goto cleanup;
if (virSecretSetValue(secret, (const unsigned char *) args->value.value_val, args->value.value_len, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int remoteDispatchSecretUndefine(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_secret_undefine_args *args);
static int remoteDispatchSecretUndefineHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchSecretUndefine(server, client, msg, rerr, args);
}
static int remoteDispatchSecretUndefine(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_secret_undefine_args *args)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(secret = get_nonnull_secret(priv->conn, args->secret)))
goto cleanup;
if (virSecretUndefine(secret) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int remoteDispatchStoragePoolBuild(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_build_args *args);
static int remoteDispatchStoragePoolBuildHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolBuild(server, client, msg, rerr, args);
}
static int remoteDispatchStoragePoolBuild(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_build_args *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolBuild(pool, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolCreate(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_create_args *args);
static int remoteDispatchStoragePoolCreateHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolCreate(server, client, msg, rerr, args);
}
static int remoteDispatchStoragePoolCreate(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_create_args *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolCreate(pool, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolCreateXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_create_xml_args *args,
remote_storage_pool_create_xml_ret *ret);
static int remoteDispatchStoragePoolCreateXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolCreateXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolCreateXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_create_xml_args *args,
remote_storage_pool_create_xml_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((pool = virStoragePoolCreateXML(priv->conn, args->xml, args->flags)) == NULL)
goto cleanup;
make_nonnull_storage_pool(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolDefineXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_define_xml_args *args,
remote_storage_pool_define_xml_ret *ret);
static int remoteDispatchStoragePoolDefineXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolDefineXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolDefineXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_define_xml_args *args,
remote_storage_pool_define_xml_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((pool = virStoragePoolDefineXML(priv->conn, args->xml, args->flags)) == NULL)
goto cleanup;
make_nonnull_storage_pool(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolDelete(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_delete_args *args);
static int remoteDispatchStoragePoolDeleteHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolDelete(server, client, msg, rerr, args);
}
static int remoteDispatchStoragePoolDelete(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_delete_args *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolDelete(pool, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolDestroy(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_destroy_args *args);
static int remoteDispatchStoragePoolDestroyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolDestroy(server, client, msg, rerr, args);
}
static int remoteDispatchStoragePoolDestroy(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_destroy_args *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolDestroy(pool) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolGetAutostart(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_get_autostart_args *args,
remote_storage_pool_get_autostart_ret *ret);
static int remoteDispatchStoragePoolGetAutostartHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolGetAutostart(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolGetAutostart(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_get_autostart_args *args,
remote_storage_pool_get_autostart_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int autostart;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolGetAutostart(pool, &autostart) < 0)
goto cleanup;
ret->autostart = autostart;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolGetInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_get_info_args *args,
remote_storage_pool_get_info_ret *ret);
static int remoteDispatchStoragePoolGetInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolGetInfo(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolGetInfo(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_get_info_args *args,
remote_storage_pool_get_info_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
virStoragePoolInfo tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolGetInfo(pool, &tmp) < 0)
goto cleanup;
ret->state = tmp.state;
ret->capacity = tmp.capacity;
ret->allocation = tmp.allocation;
ret->available = tmp.available;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_get_xml_desc_args *args,
remote_storage_pool_get_xml_desc_ret *ret);
static int remoteDispatchStoragePoolGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_get_xml_desc_args *args,
remote_storage_pool_get_xml_desc_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if ((xml = virStoragePoolGetXMLDesc(pool, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolIsActive(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_is_active_args *args,
remote_storage_pool_is_active_ret *ret);
static int remoteDispatchStoragePoolIsActiveHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolIsActive(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolIsActive(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_is_active_args *args,
remote_storage_pool_is_active_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int active;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if ((active = virStoragePoolIsActive(pool)) < 0)
goto cleanup;
ret->active = active;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolIsPersistent(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_is_persistent_args *args,
remote_storage_pool_is_persistent_ret *ret);
static int remoteDispatchStoragePoolIsPersistentHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolIsPersistent(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolIsPersistent(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_is_persistent_args *args,
remote_storage_pool_is_persistent_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int persistent;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if ((persistent = virStoragePoolIsPersistent(pool)) < 0)
goto cleanup;
ret->persistent = persistent;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolListAllVolumes(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_list_all_volumes_args *args,
remote_storage_pool_list_all_volumes_ret *ret);
static int remoteDispatchStoragePoolListAllVolumesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolListAllVolumes(server, client, msg, rerr, args, ret);
}
/* remoteDispatchStoragePoolListAllVolumes body has to be implemented manually */
static int remoteDispatchStoragePoolListVolumes(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_list_volumes_args *args,
remote_storage_pool_list_volumes_ret *ret);
static int remoteDispatchStoragePoolListVolumesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolListVolumes(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolListVolumes(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_list_volumes_args *args,
remote_storage_pool_list_volumes_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int len;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > REMOTE_STORAGE_VOL_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("maxnames > REMOTE_STORAGE_VOL_LIST_MAX"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virStoragePoolListVolumes(pool, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
VIR_FREE(ret->names.names_val);
}
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolLookupByName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_lookup_by_name_args *args,
remote_storage_pool_lookup_by_name_ret *ret);
static int remoteDispatchStoragePoolLookupByNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolLookupByName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolLookupByName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_lookup_by_name_args *args,
remote_storage_pool_lookup_by_name_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((pool = virStoragePoolLookupByName(priv->conn, args->name)) == NULL)
goto cleanup;
make_nonnull_storage_pool(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolLookupByUUID(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_lookup_by_uuid_args *args,
remote_storage_pool_lookup_by_uuid_ret *ret);
static int remoteDispatchStoragePoolLookupByUUIDHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolLookupByUUID(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolLookupByUUID(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_lookup_by_uuid_args *args,
remote_storage_pool_lookup_by_uuid_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((pool = virStoragePoolLookupByUUID(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
make_nonnull_storage_pool(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolLookupByVolume(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_lookup_by_volume_args *args,
remote_storage_pool_lookup_by_volume_ret *ret);
static int remoteDispatchStoragePoolLookupByVolumeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolLookupByVolume(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolLookupByVolume(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_lookup_by_volume_args *args,
remote_storage_pool_lookup_by_volume_ret *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if ((pool = virStoragePoolLookupByVolume(vol)) == NULL)
goto cleanup;
make_nonnull_storage_pool(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolNumOfVolumes(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_num_of_volumes_args *args,
remote_storage_pool_num_of_volumes_ret *ret);
static int remoteDispatchStoragePoolNumOfVolumesHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolNumOfVolumes(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStoragePoolNumOfVolumes(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_num_of_volumes_args *args,
remote_storage_pool_num_of_volumes_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int num;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if ((num = virStoragePoolNumOfVolumes(pool)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolRefresh(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_refresh_args *args);
static int remoteDispatchStoragePoolRefreshHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolRefresh(server, client, msg, rerr, args);
}
static int remoteDispatchStoragePoolRefresh(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_refresh_args *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolRefresh(pool, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolSetAutostart(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_set_autostart_args *args);
static int remoteDispatchStoragePoolSetAutostartHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolSetAutostart(server, client, msg, rerr, args);
}
static int remoteDispatchStoragePoolSetAutostart(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_set_autostart_args *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolSetAutostart(pool, args->autostart) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStoragePoolUndefine(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_pool_undefine_args *args);
static int remoteDispatchStoragePoolUndefineHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStoragePoolUndefine(server, client, msg, rerr, args);
}
static int remoteDispatchStoragePoolUndefine(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_pool_undefine_args *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolUndefine(pool) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int remoteDispatchStorageVolCreateXML(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_create_xml_args *args,
remote_storage_vol_create_xml_ret *ret);
static int remoteDispatchStorageVolCreateXMLHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolCreateXML(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStorageVolCreateXML(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_create_xml_args *args,
remote_storage_vol_create_xml_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if ((vol = virStorageVolCreateXML(pool, args->xml, args->flags)) == NULL)
goto cleanup;
make_nonnull_storage_vol(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolCreateXMLFrom(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_create_xml_from_args *args,
remote_storage_vol_create_xml_from_ret *ret);
static int remoteDispatchStorageVolCreateXMLFromHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolCreateXMLFrom(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStorageVolCreateXMLFrom(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_create_xml_from_args *args,
remote_storage_vol_create_xml_from_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
virStorageVolPtr clonevol = NULL;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if (!(clonevol = get_nonnull_storage_vol(priv->conn, args->clonevol)))
goto cleanup;
if ((vol = virStorageVolCreateXMLFrom(pool, args->xml, clonevol, args->flags)) == NULL)
goto cleanup;
make_nonnull_storage_vol(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
if (clonevol)
virStorageVolFree(clonevol);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolDelete(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_delete_args *args);
static int remoteDispatchStorageVolDeleteHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolDelete(server, client, msg, rerr, args);
}
static int remoteDispatchStorageVolDelete(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_delete_args *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if (virStorageVolDelete(vol, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolDownload(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_download_args *args);
static int remoteDispatchStorageVolDownloadHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolDownload(server, client, msg, rerr, args);
}
static int remoteDispatchStorageVolDownload(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_download_args *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virStreamPtr st = NULL;
daemonClientStreamPtr stream = NULL;
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = daemonCreateClientStream(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (virStorageVolDownload(vol, st, args->offset, args->length, args->flags) < 0)
goto cleanup;
if (daemonAddClientStream(client, stream, true) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
if (stream) {
virStreamAbort(st);
daemonFreeClientStream(client, stream);
} else {
virStreamFree(st);
}
}
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolGetInfo(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_get_info_args *args,
remote_storage_vol_get_info_ret *ret);
static int remoteDispatchStorageVolGetInfoHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolGetInfo(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStorageVolGetInfo(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_get_info_args *args,
remote_storage_vol_get_info_ret *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
virStorageVolInfo tmp;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if (virStorageVolGetInfo(vol, &tmp) < 0)
goto cleanup;
ret->type = tmp.type;
ret->capacity = tmp.capacity;
ret->allocation = tmp.allocation;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolGetPath(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_get_path_args *args,
remote_storage_vol_get_path_ret *ret);
static int remoteDispatchStorageVolGetPathHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolGetPath(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStorageVolGetPath(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_get_path_args *args,
remote_storage_vol_get_path_ret *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
char *name;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if ((name = virStorageVolGetPath(vol)) == NULL)
goto cleanup;
ret->name = name;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolGetXMLDesc(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_get_xml_desc_args *args,
remote_storage_vol_get_xml_desc_ret *ret);
static int remoteDispatchStorageVolGetXMLDescHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolGetXMLDesc(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStorageVolGetXMLDesc(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_get_xml_desc_args *args,
remote_storage_vol_get_xml_desc_ret *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
char *xml;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if ((xml = virStorageVolGetXMLDesc(vol, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolLookupByKey(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_lookup_by_key_args *args,
remote_storage_vol_lookup_by_key_ret *ret);
static int remoteDispatchStorageVolLookupByKeyHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolLookupByKey(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStorageVolLookupByKey(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_lookup_by_key_args *args,
remote_storage_vol_lookup_by_key_ret *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((vol = virStorageVolLookupByKey(priv->conn, args->key)) == NULL)
goto cleanup;
make_nonnull_storage_vol(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolLookupByName(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_lookup_by_name_args *args,
remote_storage_vol_lookup_by_name_ret *ret);
static int remoteDispatchStorageVolLookupByNameHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolLookupByName(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStorageVolLookupByName(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_lookup_by_name_args *args,
remote_storage_vol_lookup_by_name_ret *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
goto cleanup;
if ((vol = virStorageVolLookupByName(pool, args->name)) == NULL)
goto cleanup;
make_nonnull_storage_vol(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (pool)
virStoragePoolFree(pool);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolLookupByPath(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_lookup_by_path_args *args,
remote_storage_vol_lookup_by_path_ret *ret);
static int remoteDispatchStorageVolLookupByPathHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolLookupByPath(server, client, msg, rerr, args, ret);
}
static int remoteDispatchStorageVolLookupByPath(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_lookup_by_path_args *args,
remote_storage_vol_lookup_by_path_ret *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if ((vol = virStorageVolLookupByPath(priv->conn, args->path)) == NULL)
goto cleanup;
make_nonnull_storage_vol(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolResize(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_resize_args *args);
static int remoteDispatchStorageVolResizeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolResize(server, client, msg, rerr, args);
}
static int remoteDispatchStorageVolResize(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_resize_args *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if (virStorageVolResize(vol, args->capacity, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolUpload(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_upload_args *args);
static int remoteDispatchStorageVolUploadHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolUpload(server, client, msg, rerr, args);
}
static int remoteDispatchStorageVolUpload(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_upload_args *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virStreamPtr st = NULL;
daemonClientStreamPtr stream = NULL;
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = daemonCreateClientStream(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (virStorageVolUpload(vol, st, args->offset, args->length, args->flags) < 0)
goto cleanup;
if (daemonAddClientStream(client, stream, false) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
virNetMessageSaveError(rerr);
if (stream) {
virStreamAbort(st);
daemonFreeClientStream(client, stream);
} else {
virStreamFree(st);
}
}
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolWipe(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_wipe_args *args);
static int remoteDispatchStorageVolWipeHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolWipe(server, client, msg, rerr, args);
}
static int remoteDispatchStorageVolWipe(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_wipe_args *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if (virStorageVolWipe(vol, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int remoteDispatchStorageVolWipePattern(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
remote_storage_vol_wipe_pattern_args *args);
static int remoteDispatchStorageVolWipePatternHelper(
virNetServerPtr server,
virNetServerClientPtr client,
virNetMessagePtr msg,
virNetMessageErrorPtr rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return remoteDispatchStorageVolWipePattern(server, client, msg, rerr, args);
}
static int remoteDispatchStorageVolWipePattern(
virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr,
remote_storage_vol_wipe_pattern_args *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if (!priv->conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = get_nonnull_storage_vol(priv->conn, args->vol)))
goto cleanup;
if (virStorageVolWipePattern(vol, args->algorithm, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
virNetServerProgramProc remoteProcs[] = {
{ /* Unused 0 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectOpen => 1 */
remoteDispatchConnectOpenHelper,
sizeof(remote_connect_open_args),
(xdrproc_t)xdr_remote_connect_open_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method ConnectClose => 2 */
remoteDispatchConnectCloseHelper,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method ConnectGetType => 3 */
remoteDispatchConnectGetTypeHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_get_type_ret),
(xdrproc_t)xdr_remote_connect_get_type_ret,
true,
1
},
{ /* Method ConnectGetVersion => 4 */
remoteDispatchConnectGetVersionHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_get_version_ret),
(xdrproc_t)xdr_remote_connect_get_version_ret,
true,
1
},
{ /* Method ConnectGetMaxVcpus => 5 */
remoteDispatchConnectGetMaxVcpusHelper,
sizeof(remote_connect_get_max_vcpus_args),
(xdrproc_t)xdr_remote_connect_get_max_vcpus_args,
sizeof(remote_connect_get_max_vcpus_ret),
(xdrproc_t)xdr_remote_connect_get_max_vcpus_ret,
true,
1
},
{ /* Method NodeGetInfo => 6 */
remoteDispatchNodeGetInfoHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_node_get_info_ret),
(xdrproc_t)xdr_remote_node_get_info_ret,
true,
1
},
{ /* Method ConnectGetCapabilities => 7 */
remoteDispatchConnectGetCapabilitiesHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_get_capabilities_ret),
(xdrproc_t)xdr_remote_connect_get_capabilities_ret,
true,
0
},
{ /* Method DomainAttachDevice => 8 */
remoteDispatchDomainAttachDeviceHelper,
sizeof(remote_domain_attach_device_args),
(xdrproc_t)xdr_remote_domain_attach_device_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainCreate => 9 */
remoteDispatchDomainCreateHelper,
sizeof(remote_domain_create_args),
(xdrproc_t)xdr_remote_domain_create_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainCreateXML => 10 */
remoteDispatchDomainCreateXMLHelper,
sizeof(remote_domain_create_xml_args),
(xdrproc_t)xdr_remote_domain_create_xml_args,
sizeof(remote_domain_create_xml_ret),
(xdrproc_t)xdr_remote_domain_create_xml_ret,
true,
0
},
{ /* Method DomainDefineXML => 11 */
remoteDispatchDomainDefineXMLHelper,
sizeof(remote_domain_define_xml_args),
(xdrproc_t)xdr_remote_domain_define_xml_args,
sizeof(remote_domain_define_xml_ret),
(xdrproc_t)xdr_remote_domain_define_xml_ret,
true,
1
},
{ /* Method DomainDestroy => 12 */
remoteDispatchDomainDestroyHelper,
sizeof(remote_domain_destroy_args),
(xdrproc_t)xdr_remote_domain_destroy_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainDetachDevice => 13 */
remoteDispatchDomainDetachDeviceHelper,
sizeof(remote_domain_detach_device_args),
(xdrproc_t)xdr_remote_domain_detach_device_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetXMLDesc => 14 */
remoteDispatchDomainGetXMLDescHelper,
sizeof(remote_domain_get_xml_desc_args),
(xdrproc_t)xdr_remote_domain_get_xml_desc_args,
sizeof(remote_domain_get_xml_desc_ret),
(xdrproc_t)xdr_remote_domain_get_xml_desc_ret,
true,
0
},
{ /* Method DomainGetAutostart => 15 */
remoteDispatchDomainGetAutostartHelper,
sizeof(remote_domain_get_autostart_args),
(xdrproc_t)xdr_remote_domain_get_autostart_args,
sizeof(remote_domain_get_autostart_ret),
(xdrproc_t)xdr_remote_domain_get_autostart_ret,
true,
1
},
{ /* Method DomainGetInfo => 16 */
remoteDispatchDomainGetInfoHelper,
sizeof(remote_domain_get_info_args),
(xdrproc_t)xdr_remote_domain_get_info_args,
sizeof(remote_domain_get_info_ret),
(xdrproc_t)xdr_remote_domain_get_info_ret,
true,
0
},
{ /* Method DomainGetMaxMemory => 17 */
remoteDispatchDomainGetMaxMemoryHelper,
sizeof(remote_domain_get_max_memory_args),
(xdrproc_t)xdr_remote_domain_get_max_memory_args,
sizeof(remote_domain_get_max_memory_ret),
(xdrproc_t)xdr_remote_domain_get_max_memory_ret,
true,
1
},
{ /* Method DomainGetMaxVcpus => 18 */
remoteDispatchDomainGetMaxVcpusHelper,
sizeof(remote_domain_get_max_vcpus_args),
(xdrproc_t)xdr_remote_domain_get_max_vcpus_args,
sizeof(remote_domain_get_max_vcpus_ret),
(xdrproc_t)xdr_remote_domain_get_max_vcpus_ret,
true,
1
},
{ /* Method DomainGetOSType => 19 */
remoteDispatchDomainGetOSTypeHelper,
sizeof(remote_domain_get_os_type_args),
(xdrproc_t)xdr_remote_domain_get_os_type_args,
sizeof(remote_domain_get_os_type_ret),
(xdrproc_t)xdr_remote_domain_get_os_type_ret,
true,
1
},
{ /* Method DomainGetVcpus => 20 */
remoteDispatchDomainGetVcpusHelper,
sizeof(remote_domain_get_vcpus_args),
(xdrproc_t)xdr_remote_domain_get_vcpus_args,
sizeof(remote_domain_get_vcpus_ret),
(xdrproc_t)xdr_remote_domain_get_vcpus_ret,
true,
1
},
{ /* Method ConnectListDefinedDomains => 21 */
remoteDispatchConnectListDefinedDomainsHelper,
sizeof(remote_connect_list_defined_domains_args),
(xdrproc_t)xdr_remote_connect_list_defined_domains_args,
sizeof(remote_connect_list_defined_domains_ret),
(xdrproc_t)xdr_remote_connect_list_defined_domains_ret,
true,
1
},
{ /* Method DomainLookupByID => 22 */
remoteDispatchDomainLookupByIDHelper,
sizeof(remote_domain_lookup_by_id_args),
(xdrproc_t)xdr_remote_domain_lookup_by_id_args,
sizeof(remote_domain_lookup_by_id_ret),
(xdrproc_t)xdr_remote_domain_lookup_by_id_ret,
true,
1
},
{ /* Method DomainLookupByName => 23 */
remoteDispatchDomainLookupByNameHelper,
sizeof(remote_domain_lookup_by_name_args),
(xdrproc_t)xdr_remote_domain_lookup_by_name_args,
sizeof(remote_domain_lookup_by_name_ret),
(xdrproc_t)xdr_remote_domain_lookup_by_name_ret,
true,
1
},
{ /* Method DomainLookupByUUID => 24 */
remoteDispatchDomainLookupByUUIDHelper,
sizeof(remote_domain_lookup_by_uuid_args),
(xdrproc_t)xdr_remote_domain_lookup_by_uuid_args,
sizeof(remote_domain_lookup_by_uuid_ret),
(xdrproc_t)xdr_remote_domain_lookup_by_uuid_ret,
true,
1
},
{ /* Method ConnectNumOfDefinedDomains => 25 */
remoteDispatchConnectNumOfDefinedDomainsHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_defined_domains_ret),
(xdrproc_t)xdr_remote_connect_num_of_defined_domains_ret,
true,
1
},
{ /* Method DomainPinVcpu => 26 */
remoteDispatchDomainPinVcpuHelper,
sizeof(remote_domain_pin_vcpu_args),
(xdrproc_t)xdr_remote_domain_pin_vcpu_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainReboot => 27 */
remoteDispatchDomainRebootHelper,
sizeof(remote_domain_reboot_args),
(xdrproc_t)xdr_remote_domain_reboot_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainResume => 28 */
remoteDispatchDomainResumeHelper,
sizeof(remote_domain_resume_args),
(xdrproc_t)xdr_remote_domain_resume_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSetAutostart => 29 */
remoteDispatchDomainSetAutostartHelper,
sizeof(remote_domain_set_autostart_args),
(xdrproc_t)xdr_remote_domain_set_autostart_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainSetMaxMemory => 30 */
remoteDispatchDomainSetMaxMemoryHelper,
sizeof(remote_domain_set_max_memory_args),
(xdrproc_t)xdr_remote_domain_set_max_memory_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainSetMemory => 31 */
remoteDispatchDomainSetMemoryHelper,
sizeof(remote_domain_set_memory_args),
(xdrproc_t)xdr_remote_domain_set_memory_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSetVcpus => 32 */
remoteDispatchDomainSetVcpusHelper,
sizeof(remote_domain_set_vcpus_args),
(xdrproc_t)xdr_remote_domain_set_vcpus_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainShutdown => 33 */
remoteDispatchDomainShutdownHelper,
sizeof(remote_domain_shutdown_args),
(xdrproc_t)xdr_remote_domain_shutdown_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSuspend => 34 */
remoteDispatchDomainSuspendHelper,
sizeof(remote_domain_suspend_args),
(xdrproc_t)xdr_remote_domain_suspend_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainUndefine => 35 */
remoteDispatchDomainUndefineHelper,
sizeof(remote_domain_undefine_args),
(xdrproc_t)xdr_remote_domain_undefine_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method ConnectListDefinedNetworks => 36 */
remoteDispatchConnectListDefinedNetworksHelper,
sizeof(remote_connect_list_defined_networks_args),
(xdrproc_t)xdr_remote_connect_list_defined_networks_args,
sizeof(remote_connect_list_defined_networks_ret),
(xdrproc_t)xdr_remote_connect_list_defined_networks_ret,
true,
1
},
{ /* Method ConnectListDomains => 37 */
remoteDispatchConnectListDomainsHelper,
sizeof(remote_connect_list_domains_args),
(xdrproc_t)xdr_remote_connect_list_domains_args,
sizeof(remote_connect_list_domains_ret),
(xdrproc_t)xdr_remote_connect_list_domains_ret,
true,
1
},
{ /* Method ConnectListNetworks => 38 */
remoteDispatchConnectListNetworksHelper,
sizeof(remote_connect_list_networks_args),
(xdrproc_t)xdr_remote_connect_list_networks_args,
sizeof(remote_connect_list_networks_ret),
(xdrproc_t)xdr_remote_connect_list_networks_ret,
true,
1
},
{ /* Method NetworkCreate => 39 */
remoteDispatchNetworkCreateHelper,
sizeof(remote_network_create_args),
(xdrproc_t)xdr_remote_network_create_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NetworkCreateXML => 40 */
remoteDispatchNetworkCreateXMLHelper,
sizeof(remote_network_create_xml_args),
(xdrproc_t)xdr_remote_network_create_xml_args,
sizeof(remote_network_create_xml_ret),
(xdrproc_t)xdr_remote_network_create_xml_ret,
true,
0
},
{ /* Method NetworkDefineXML => 41 */
remoteDispatchNetworkDefineXMLHelper,
sizeof(remote_network_define_xml_args),
(xdrproc_t)xdr_remote_network_define_xml_args,
sizeof(remote_network_define_xml_ret),
(xdrproc_t)xdr_remote_network_define_xml_ret,
true,
1
},
{ /* Method NetworkDestroy => 42 */
remoteDispatchNetworkDestroyHelper,
sizeof(remote_network_destroy_args),
(xdrproc_t)xdr_remote_network_destroy_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method NetworkGetXMLDesc => 43 */
remoteDispatchNetworkGetXMLDescHelper,
sizeof(remote_network_get_xml_desc_args),
(xdrproc_t)xdr_remote_network_get_xml_desc_args,
sizeof(remote_network_get_xml_desc_ret),
(xdrproc_t)xdr_remote_network_get_xml_desc_ret,
true,
1
},
{ /* Method NetworkGetAutostart => 44 */
remoteDispatchNetworkGetAutostartHelper,
sizeof(remote_network_get_autostart_args),
(xdrproc_t)xdr_remote_network_get_autostart_args,
sizeof(remote_network_get_autostart_ret),
(xdrproc_t)xdr_remote_network_get_autostart_ret,
true,
1
},
{ /* Method NetworkGetBridgeName => 45 */
remoteDispatchNetworkGetBridgeNameHelper,
sizeof(remote_network_get_bridge_name_args),
(xdrproc_t)xdr_remote_network_get_bridge_name_args,
sizeof(remote_network_get_bridge_name_ret),
(xdrproc_t)xdr_remote_network_get_bridge_name_ret,
true,
1
},
{ /* Method NetworkLookupByName => 46 */
remoteDispatchNetworkLookupByNameHelper,
sizeof(remote_network_lookup_by_name_args),
(xdrproc_t)xdr_remote_network_lookup_by_name_args,
sizeof(remote_network_lookup_by_name_ret),
(xdrproc_t)xdr_remote_network_lookup_by_name_ret,
true,
1
},
{ /* Method NetworkLookupByUUID => 47 */
remoteDispatchNetworkLookupByUUIDHelper,
sizeof(remote_network_lookup_by_uuid_args),
(xdrproc_t)xdr_remote_network_lookup_by_uuid_args,
sizeof(remote_network_lookup_by_uuid_ret),
(xdrproc_t)xdr_remote_network_lookup_by_uuid_ret,
true,
1
},
{ /* Method NetworkSetAutostart => 48 */
remoteDispatchNetworkSetAutostartHelper,
sizeof(remote_network_set_autostart_args),
(xdrproc_t)xdr_remote_network_set_autostart_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method NetworkUndefine => 49 */
remoteDispatchNetworkUndefineHelper,
sizeof(remote_network_undefine_args),
(xdrproc_t)xdr_remote_network_undefine_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method ConnectNumOfDefinedNetworks => 50 */
remoteDispatchConnectNumOfDefinedNetworksHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_defined_networks_ret),
(xdrproc_t)xdr_remote_connect_num_of_defined_networks_ret,
true,
1
},
{ /* Method ConnectNumOfDomains => 51 */
remoteDispatchConnectNumOfDomainsHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_domains_ret),
(xdrproc_t)xdr_remote_connect_num_of_domains_ret,
true,
1
},
{ /* Method ConnectNumOfNetworks => 52 */
remoteDispatchConnectNumOfNetworksHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_networks_ret),
(xdrproc_t)xdr_remote_connect_num_of_networks_ret,
true,
1
},
{ /* Method DomainCoreDump => 53 */
remoteDispatchDomainCoreDumpHelper,
sizeof(remote_domain_core_dump_args),
(xdrproc_t)xdr_remote_domain_core_dump_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainRestore => 54 */
remoteDispatchDomainRestoreHelper,
sizeof(remote_domain_restore_args),
(xdrproc_t)xdr_remote_domain_restore_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSave => 55 */
remoteDispatchDomainSaveHelper,
sizeof(remote_domain_save_args),
(xdrproc_t)xdr_remote_domain_save_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetSchedulerType => 56 */
remoteDispatchDomainGetSchedulerTypeHelper,
sizeof(remote_domain_get_scheduler_type_args),
(xdrproc_t)xdr_remote_domain_get_scheduler_type_args,
sizeof(remote_domain_get_scheduler_type_ret),
(xdrproc_t)xdr_remote_domain_get_scheduler_type_ret,
true,
0
},
{ /* Method DomainGetSchedulerParameters => 57 */
remoteDispatchDomainGetSchedulerParametersHelper,
sizeof(remote_domain_get_scheduler_parameters_args),
(xdrproc_t)xdr_remote_domain_get_scheduler_parameters_args,
sizeof(remote_domain_get_scheduler_parameters_ret),
(xdrproc_t)xdr_remote_domain_get_scheduler_parameters_ret,
true,
0
},
{ /* Method DomainSetSchedulerParameters => 58 */
remoteDispatchDomainSetSchedulerParametersHelper,
sizeof(remote_domain_set_scheduler_parameters_args),
(xdrproc_t)xdr_remote_domain_set_scheduler_parameters_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectGetHostname => 59 */
remoteDispatchConnectGetHostnameHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_get_hostname_ret),
(xdrproc_t)xdr_remote_connect_get_hostname_ret,
true,
1
},
{ /* Method ConnectSupportsFeature => 60 */
remoteDispatchConnectSupportsFeatureHelper,
sizeof(remote_connect_supports_feature_args),
(xdrproc_t)xdr_remote_connect_supports_feature_args,
sizeof(remote_connect_supports_feature_ret),
(xdrproc_t)xdr_remote_connect_supports_feature_ret,
true,
1
},
{ /* Method DomainMigratePrepare => 61 */
remoteDispatchDomainMigratePrepareHelper,
sizeof(remote_domain_migrate_prepare_args),
(xdrproc_t)xdr_remote_domain_migrate_prepare_args,
sizeof(remote_domain_migrate_prepare_ret),
(xdrproc_t)xdr_remote_domain_migrate_prepare_ret,
true,
0
},
{ /* Method DomainMigratePerform => 62 */
remoteDispatchDomainMigratePerformHelper,
sizeof(remote_domain_migrate_perform_args),
(xdrproc_t)xdr_remote_domain_migrate_perform_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainMigrateFinish => 63 */
remoteDispatchDomainMigrateFinishHelper,
sizeof(remote_domain_migrate_finish_args),
(xdrproc_t)xdr_remote_domain_migrate_finish_args,
sizeof(remote_domain_migrate_finish_ret),
(xdrproc_t)xdr_remote_domain_migrate_finish_ret,
true,
0
},
{ /* Method DomainBlockStats => 64 */
remoteDispatchDomainBlockStatsHelper,
sizeof(remote_domain_block_stats_args),
(xdrproc_t)xdr_remote_domain_block_stats_args,
sizeof(remote_domain_block_stats_ret),
(xdrproc_t)xdr_remote_domain_block_stats_ret,
true,
0
},
{ /* Method DomainInterfaceStats => 65 */
remoteDispatchDomainInterfaceStatsHelper,
sizeof(remote_domain_interface_stats_args),
(xdrproc_t)xdr_remote_domain_interface_stats_args,
sizeof(remote_domain_interface_stats_ret),
(xdrproc_t)xdr_remote_domain_interface_stats_ret,
true,
1
},
{ /* Method AuthList => 66 */
remoteDispatchAuthListHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_auth_list_ret),
(xdrproc_t)xdr_remote_auth_list_ret,
true,
1
},
{ /* Method AuthSaslInit => 67 */
remoteDispatchAuthSaslInitHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_auth_sasl_init_ret),
(xdrproc_t)xdr_remote_auth_sasl_init_ret,
true,
1
},
{ /* Method AuthSaslStart => 68 */
remoteDispatchAuthSaslStartHelper,
sizeof(remote_auth_sasl_start_args),
(xdrproc_t)xdr_remote_auth_sasl_start_args,
sizeof(remote_auth_sasl_start_ret),
(xdrproc_t)xdr_remote_auth_sasl_start_ret,
true,
1
},
{ /* Method AuthSaslStep => 69 */
remoteDispatchAuthSaslStepHelper,
sizeof(remote_auth_sasl_step_args),
(xdrproc_t)xdr_remote_auth_sasl_step_args,
sizeof(remote_auth_sasl_step_ret),
(xdrproc_t)xdr_remote_auth_sasl_step_ret,
true,
1
},
{ /* Method AuthPolkit => 70 */
remoteDispatchAuthPolkitHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_auth_polkit_ret),
(xdrproc_t)xdr_remote_auth_polkit_ret,
true,
1
},
{ /* Method ConnectNumOfStoragePools => 71 */
remoteDispatchConnectNumOfStoragePoolsHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_storage_pools_ret),
(xdrproc_t)xdr_remote_connect_num_of_storage_pools_ret,
true,
1
},
{ /* Method ConnectListStoragePools => 72 */
remoteDispatchConnectListStoragePoolsHelper,
sizeof(remote_connect_list_storage_pools_args),
(xdrproc_t)xdr_remote_connect_list_storage_pools_args,
sizeof(remote_connect_list_storage_pools_ret),
(xdrproc_t)xdr_remote_connect_list_storage_pools_ret,
true,
1
},
{ /* Method ConnectNumOfDefinedStoragePools => 73 */
remoteDispatchConnectNumOfDefinedStoragePoolsHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_defined_storage_pools_ret),
(xdrproc_t)xdr_remote_connect_num_of_defined_storage_pools_ret,
true,
1
},
{ /* Method ConnectListDefinedStoragePools => 74 */
remoteDispatchConnectListDefinedStoragePoolsHelper,
sizeof(remote_connect_list_defined_storage_pools_args),
(xdrproc_t)xdr_remote_connect_list_defined_storage_pools_args,
sizeof(remote_connect_list_defined_storage_pools_ret),
(xdrproc_t)xdr_remote_connect_list_defined_storage_pools_ret,
true,
1
},
{ /* Method ConnectFindStoragePoolSources => 75 */
remoteDispatchConnectFindStoragePoolSourcesHelper,
sizeof(remote_connect_find_storage_pool_sources_args),
(xdrproc_t)xdr_remote_connect_find_storage_pool_sources_args,
sizeof(remote_connect_find_storage_pool_sources_ret),
(xdrproc_t)xdr_remote_connect_find_storage_pool_sources_ret,
true,
0
},
{ /* Method StoragePoolCreateXML => 76 */
remoteDispatchStoragePoolCreateXMLHelper,
sizeof(remote_storage_pool_create_xml_args),
(xdrproc_t)xdr_remote_storage_pool_create_xml_args,
sizeof(remote_storage_pool_create_xml_ret),
(xdrproc_t)xdr_remote_storage_pool_create_xml_ret,
true,
0
},
{ /* Method StoragePoolDefineXML => 77 */
remoteDispatchStoragePoolDefineXMLHelper,
sizeof(remote_storage_pool_define_xml_args),
(xdrproc_t)xdr_remote_storage_pool_define_xml_args,
sizeof(remote_storage_pool_define_xml_ret),
(xdrproc_t)xdr_remote_storage_pool_define_xml_ret,
true,
1
},
{ /* Method StoragePoolCreate => 78 */
remoteDispatchStoragePoolCreateHelper,
sizeof(remote_storage_pool_create_args),
(xdrproc_t)xdr_remote_storage_pool_create_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StoragePoolBuild => 79 */
remoteDispatchStoragePoolBuildHelper,
sizeof(remote_storage_pool_build_args),
(xdrproc_t)xdr_remote_storage_pool_build_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StoragePoolDestroy => 80 */
remoteDispatchStoragePoolDestroyHelper,
sizeof(remote_storage_pool_destroy_args),
(xdrproc_t)xdr_remote_storage_pool_destroy_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method StoragePoolDelete => 81 */
remoteDispatchStoragePoolDeleteHelper,
sizeof(remote_storage_pool_delete_args),
(xdrproc_t)xdr_remote_storage_pool_delete_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StoragePoolUndefine => 82 */
remoteDispatchStoragePoolUndefineHelper,
sizeof(remote_storage_pool_undefine_args),
(xdrproc_t)xdr_remote_storage_pool_undefine_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method StoragePoolRefresh => 83 */
remoteDispatchStoragePoolRefreshHelper,
sizeof(remote_storage_pool_refresh_args),
(xdrproc_t)xdr_remote_storage_pool_refresh_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StoragePoolLookupByName => 84 */
remoteDispatchStoragePoolLookupByNameHelper,
sizeof(remote_storage_pool_lookup_by_name_args),
(xdrproc_t)xdr_remote_storage_pool_lookup_by_name_args,
sizeof(remote_storage_pool_lookup_by_name_ret),
(xdrproc_t)xdr_remote_storage_pool_lookup_by_name_ret,
true,
1
},
{ /* Method StoragePoolLookupByUUID => 85 */
remoteDispatchStoragePoolLookupByUUIDHelper,
sizeof(remote_storage_pool_lookup_by_uuid_args),
(xdrproc_t)xdr_remote_storage_pool_lookup_by_uuid_args,
sizeof(remote_storage_pool_lookup_by_uuid_ret),
(xdrproc_t)xdr_remote_storage_pool_lookup_by_uuid_ret,
true,
1
},
{ /* Method StoragePoolLookupByVolume => 86 */
remoteDispatchStoragePoolLookupByVolumeHelper,
sizeof(remote_storage_pool_lookup_by_volume_args),
(xdrproc_t)xdr_remote_storage_pool_lookup_by_volume_args,
sizeof(remote_storage_pool_lookup_by_volume_ret),
(xdrproc_t)xdr_remote_storage_pool_lookup_by_volume_ret,
true,
1
},
{ /* Method StoragePoolGetInfo => 87 */
remoteDispatchStoragePoolGetInfoHelper,
sizeof(remote_storage_pool_get_info_args),
(xdrproc_t)xdr_remote_storage_pool_get_info_args,
sizeof(remote_storage_pool_get_info_ret),
(xdrproc_t)xdr_remote_storage_pool_get_info_ret,
true,
1
},
{ /* Method StoragePoolGetXMLDesc => 88 */
remoteDispatchStoragePoolGetXMLDescHelper,
sizeof(remote_storage_pool_get_xml_desc_args),
(xdrproc_t)xdr_remote_storage_pool_get_xml_desc_args,
sizeof(remote_storage_pool_get_xml_desc_ret),
(xdrproc_t)xdr_remote_storage_pool_get_xml_desc_ret,
true,
1
},
{ /* Method StoragePoolGetAutostart => 89 */
remoteDispatchStoragePoolGetAutostartHelper,
sizeof(remote_storage_pool_get_autostart_args),
(xdrproc_t)xdr_remote_storage_pool_get_autostart_args,
sizeof(remote_storage_pool_get_autostart_ret),
(xdrproc_t)xdr_remote_storage_pool_get_autostart_ret,
true,
1
},
{ /* Method StoragePoolSetAutostart => 90 */
remoteDispatchStoragePoolSetAutostartHelper,
sizeof(remote_storage_pool_set_autostart_args),
(xdrproc_t)xdr_remote_storage_pool_set_autostart_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method StoragePoolNumOfVolumes => 91 */
remoteDispatchStoragePoolNumOfVolumesHelper,
sizeof(remote_storage_pool_num_of_volumes_args),
(xdrproc_t)xdr_remote_storage_pool_num_of_volumes_args,
sizeof(remote_storage_pool_num_of_volumes_ret),
(xdrproc_t)xdr_remote_storage_pool_num_of_volumes_ret,
true,
1
},
{ /* Method StoragePoolListVolumes => 92 */
remoteDispatchStoragePoolListVolumesHelper,
sizeof(remote_storage_pool_list_volumes_args),
(xdrproc_t)xdr_remote_storage_pool_list_volumes_args,
sizeof(remote_storage_pool_list_volumes_ret),
(xdrproc_t)xdr_remote_storage_pool_list_volumes_ret,
true,
1
},
{ /* Method StorageVolCreateXML => 93 */
remoteDispatchStorageVolCreateXMLHelper,
sizeof(remote_storage_vol_create_xml_args),
(xdrproc_t)xdr_remote_storage_vol_create_xml_args,
sizeof(remote_storage_vol_create_xml_ret),
(xdrproc_t)xdr_remote_storage_vol_create_xml_ret,
true,
0
},
{ /* Method StorageVolDelete => 94 */
remoteDispatchStorageVolDeleteHelper,
sizeof(remote_storage_vol_delete_args),
(xdrproc_t)xdr_remote_storage_vol_delete_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolLookupByName => 95 */
remoteDispatchStorageVolLookupByNameHelper,
sizeof(remote_storage_vol_lookup_by_name_args),
(xdrproc_t)xdr_remote_storage_vol_lookup_by_name_args,
sizeof(remote_storage_vol_lookup_by_name_ret),
(xdrproc_t)xdr_remote_storage_vol_lookup_by_name_ret,
true,
1
},
{ /* Method StorageVolLookupByKey => 96 */
remoteDispatchStorageVolLookupByKeyHelper,
sizeof(remote_storage_vol_lookup_by_key_args),
(xdrproc_t)xdr_remote_storage_vol_lookup_by_key_args,
sizeof(remote_storage_vol_lookup_by_key_ret),
(xdrproc_t)xdr_remote_storage_vol_lookup_by_key_ret,
true,
1
},
{ /* Method StorageVolLookupByPath => 97 */
remoteDispatchStorageVolLookupByPathHelper,
sizeof(remote_storage_vol_lookup_by_path_args),
(xdrproc_t)xdr_remote_storage_vol_lookup_by_path_args,
sizeof(remote_storage_vol_lookup_by_path_ret),
(xdrproc_t)xdr_remote_storage_vol_lookup_by_path_ret,
true,
1
},
{ /* Method StorageVolGetInfo => 98 */
remoteDispatchStorageVolGetInfoHelper,
sizeof(remote_storage_vol_get_info_args),
(xdrproc_t)xdr_remote_storage_vol_get_info_args,
sizeof(remote_storage_vol_get_info_ret),
(xdrproc_t)xdr_remote_storage_vol_get_info_ret,
true,
1
},
{ /* Method StorageVolGetXMLDesc => 99 */
remoteDispatchStorageVolGetXMLDescHelper,
sizeof(remote_storage_vol_get_xml_desc_args),
(xdrproc_t)xdr_remote_storage_vol_get_xml_desc_args,
sizeof(remote_storage_vol_get_xml_desc_ret),
(xdrproc_t)xdr_remote_storage_vol_get_xml_desc_ret,
true,
1
},
{ /* Method StorageVolGetPath => 100 */
remoteDispatchStorageVolGetPathHelper,
sizeof(remote_storage_vol_get_path_args),
(xdrproc_t)xdr_remote_storage_vol_get_path_args,
sizeof(remote_storage_vol_get_path_ret),
(xdrproc_t)xdr_remote_storage_vol_get_path_ret,
true,
1
},
{ /* Method NodeGetCellsFreeMemory => 101 */
remoteDispatchNodeGetCellsFreeMemoryHelper,
sizeof(remote_node_get_cells_free_memory_args),
(xdrproc_t)xdr_remote_node_get_cells_free_memory_args,
sizeof(remote_node_get_cells_free_memory_ret),
(xdrproc_t)xdr_remote_node_get_cells_free_memory_ret,
true,
1
},
{ /* Method NodeGetFreeMemory => 102 */
remoteDispatchNodeGetFreeMemoryHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_node_get_free_memory_ret),
(xdrproc_t)xdr_remote_node_get_free_memory_ret,
true,
1
},
{ /* Method DomainBlockPeek => 103 */
remoteDispatchDomainBlockPeekHelper,
sizeof(remote_domain_block_peek_args),
(xdrproc_t)xdr_remote_domain_block_peek_args,
sizeof(remote_domain_block_peek_ret),
(xdrproc_t)xdr_remote_domain_block_peek_ret,
true,
0
},
{ /* Method DomainMemoryPeek => 104 */
remoteDispatchDomainMemoryPeekHelper,
sizeof(remote_domain_memory_peek_args),
(xdrproc_t)xdr_remote_domain_memory_peek_args,
sizeof(remote_domain_memory_peek_ret),
(xdrproc_t)xdr_remote_domain_memory_peek_ret,
true,
0
},
{ /* Method ConnectDomainEventRegister => 105 */
remoteDispatchConnectDomainEventRegisterHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_domain_event_register_ret),
(xdrproc_t)xdr_remote_connect_domain_event_register_ret,
true,
1
},
{ /* Method ConnectDomainEventDeregister => 106 */
remoteDispatchConnectDomainEventDeregisterHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_domain_event_deregister_ret),
(xdrproc_t)xdr_remote_connect_domain_event_deregister_ret,
true,
1
},
{ /* Async event DomainEventLifecycle => 107 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainMigratePrepare2 => 108 */
remoteDispatchDomainMigratePrepare2Helper,
sizeof(remote_domain_migrate_prepare2_args),
(xdrproc_t)xdr_remote_domain_migrate_prepare2_args,
sizeof(remote_domain_migrate_prepare2_ret),
(xdrproc_t)xdr_remote_domain_migrate_prepare2_ret,
true,
0
},
{ /* Method DomainMigrateFinish2 => 109 */
remoteDispatchDomainMigrateFinish2Helper,
sizeof(remote_domain_migrate_finish2_args),
(xdrproc_t)xdr_remote_domain_migrate_finish2_args,
sizeof(remote_domain_migrate_finish2_ret),
(xdrproc_t)xdr_remote_domain_migrate_finish2_ret,
true,
0
},
{ /* Method ConnectGetURI => 110 */
remoteDispatchConnectGetURIHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_get_uri_ret),
(xdrproc_t)xdr_remote_connect_get_uri_ret,
true,
1
},
{ /* Method NodeNumOfDevices => 111 */
remoteDispatchNodeNumOfDevicesHelper,
sizeof(remote_node_num_of_devices_args),
(xdrproc_t)xdr_remote_node_num_of_devices_args,
sizeof(remote_node_num_of_devices_ret),
(xdrproc_t)xdr_remote_node_num_of_devices_ret,
true,
1
},
{ /* Method NodeListDevices => 112 */
remoteDispatchNodeListDevicesHelper,
sizeof(remote_node_list_devices_args),
(xdrproc_t)xdr_remote_node_list_devices_args,
sizeof(remote_node_list_devices_ret),
(xdrproc_t)xdr_remote_node_list_devices_ret,
true,
1
},
{ /* Method NodeDeviceLookupByName => 113 */
remoteDispatchNodeDeviceLookupByNameHelper,
sizeof(remote_node_device_lookup_by_name_args),
(xdrproc_t)xdr_remote_node_device_lookup_by_name_args,
sizeof(remote_node_device_lookup_by_name_ret),
(xdrproc_t)xdr_remote_node_device_lookup_by_name_ret,
true,
1
},
{ /* Method NodeDeviceGetXMLDesc => 114 */
remoteDispatchNodeDeviceGetXMLDescHelper,
sizeof(remote_node_device_get_xml_desc_args),
(xdrproc_t)xdr_remote_node_device_get_xml_desc_args,
sizeof(remote_node_device_get_xml_desc_ret),
(xdrproc_t)xdr_remote_node_device_get_xml_desc_ret,
true,
0
},
{ /* Method NodeDeviceGetParent => 115 */
remoteDispatchNodeDeviceGetParentHelper,
sizeof(remote_node_device_get_parent_args),
(xdrproc_t)xdr_remote_node_device_get_parent_args,
sizeof(remote_node_device_get_parent_ret),
(xdrproc_t)xdr_remote_node_device_get_parent_ret,
true,
1
},
{ /* Method NodeDeviceNumOfCaps => 116 */
remoteDispatchNodeDeviceNumOfCapsHelper,
sizeof(remote_node_device_num_of_caps_args),
(xdrproc_t)xdr_remote_node_device_num_of_caps_args,
sizeof(remote_node_device_num_of_caps_ret),
(xdrproc_t)xdr_remote_node_device_num_of_caps_ret,
true,
1
},
{ /* Method NodeDeviceListCaps => 117 */
remoteDispatchNodeDeviceListCapsHelper,
sizeof(remote_node_device_list_caps_args),
(xdrproc_t)xdr_remote_node_device_list_caps_args,
sizeof(remote_node_device_list_caps_ret),
(xdrproc_t)xdr_remote_node_device_list_caps_ret,
true,
1
},
{ /* Method NodeDeviceDettach => 118 */
remoteDispatchNodeDeviceDettachHelper,
sizeof(remote_node_device_dettach_args),
(xdrproc_t)xdr_remote_node_device_dettach_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeDeviceReAttach => 119 */
remoteDispatchNodeDeviceReAttachHelper,
sizeof(remote_node_device_re_attach_args),
(xdrproc_t)xdr_remote_node_device_re_attach_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeDeviceReset => 120 */
remoteDispatchNodeDeviceResetHelper,
sizeof(remote_node_device_reset_args),
(xdrproc_t)xdr_remote_node_device_reset_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetSecurityLabel => 121 */
remoteDispatchDomainGetSecurityLabelHelper,
sizeof(remote_domain_get_security_label_args),
(xdrproc_t)xdr_remote_domain_get_security_label_args,
sizeof(remote_domain_get_security_label_ret),
(xdrproc_t)xdr_remote_domain_get_security_label_ret,
true,
1
},
{ /* Method NodeGetSecurityModel => 122 */
remoteDispatchNodeGetSecurityModelHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_node_get_security_model_ret),
(xdrproc_t)xdr_remote_node_get_security_model_ret,
true,
1
},
{ /* Method NodeDeviceCreateXML => 123 */
remoteDispatchNodeDeviceCreateXMLHelper,
sizeof(remote_node_device_create_xml_args),
(xdrproc_t)xdr_remote_node_device_create_xml_args,
sizeof(remote_node_device_create_xml_ret),
(xdrproc_t)xdr_remote_node_device_create_xml_ret,
true,
0
},
{ /* Method NodeDeviceDestroy => 124 */
remoteDispatchNodeDeviceDestroyHelper,
sizeof(remote_node_device_destroy_args),
(xdrproc_t)xdr_remote_node_device_destroy_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method StorageVolCreateXMLFrom => 125 */
remoteDispatchStorageVolCreateXMLFromHelper,
sizeof(remote_storage_vol_create_xml_from_args),
(xdrproc_t)xdr_remote_storage_vol_create_xml_from_args,
sizeof(remote_storage_vol_create_xml_from_ret),
(xdrproc_t)xdr_remote_storage_vol_create_xml_from_ret,
true,
0
},
{ /* Method ConnectNumOfInterfaces => 126 */
remoteDispatchConnectNumOfInterfacesHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_interfaces_ret),
(xdrproc_t)xdr_remote_connect_num_of_interfaces_ret,
true,
1
},
{ /* Method ConnectListInterfaces => 127 */
remoteDispatchConnectListInterfacesHelper,
sizeof(remote_connect_list_interfaces_args),
(xdrproc_t)xdr_remote_connect_list_interfaces_args,
sizeof(remote_connect_list_interfaces_ret),
(xdrproc_t)xdr_remote_connect_list_interfaces_ret,
true,
1
},
{ /* Method InterfaceLookupByName => 128 */
remoteDispatchInterfaceLookupByNameHelper,
sizeof(remote_interface_lookup_by_name_args),
(xdrproc_t)xdr_remote_interface_lookup_by_name_args,
sizeof(remote_interface_lookup_by_name_ret),
(xdrproc_t)xdr_remote_interface_lookup_by_name_ret,
true,
1
},
{ /* Method InterfaceLookupByMACString => 129 */
remoteDispatchInterfaceLookupByMACStringHelper,
sizeof(remote_interface_lookup_by_mac_string_args),
(xdrproc_t)xdr_remote_interface_lookup_by_mac_string_args,
sizeof(remote_interface_lookup_by_mac_string_ret),
(xdrproc_t)xdr_remote_interface_lookup_by_mac_string_ret,
true,
1
},
{ /* Method InterfaceGetXMLDesc => 130 */
remoteDispatchInterfaceGetXMLDescHelper,
sizeof(remote_interface_get_xml_desc_args),
(xdrproc_t)xdr_remote_interface_get_xml_desc_args,
sizeof(remote_interface_get_xml_desc_ret),
(xdrproc_t)xdr_remote_interface_get_xml_desc_ret,
true,
0
},
{ /* Method InterfaceDefineXML => 131 */
remoteDispatchInterfaceDefineXMLHelper,
sizeof(remote_interface_define_xml_args),
(xdrproc_t)xdr_remote_interface_define_xml_args,
sizeof(remote_interface_define_xml_ret),
(xdrproc_t)xdr_remote_interface_define_xml_ret,
true,
1
},
{ /* Method InterfaceUndefine => 132 */
remoteDispatchInterfaceUndefineHelper,
sizeof(remote_interface_undefine_args),
(xdrproc_t)xdr_remote_interface_undefine_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method InterfaceCreate => 133 */
remoteDispatchInterfaceCreateHelper,
sizeof(remote_interface_create_args),
(xdrproc_t)xdr_remote_interface_create_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method InterfaceDestroy => 134 */
remoteDispatchInterfaceDestroyHelper,
sizeof(remote_interface_destroy_args),
(xdrproc_t)xdr_remote_interface_destroy_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method ConnectDomainXMLFromNative => 135 */
remoteDispatchConnectDomainXMLFromNativeHelper,
sizeof(remote_connect_domain_xml_from_native_args),
(xdrproc_t)xdr_remote_connect_domain_xml_from_native_args,
sizeof(remote_connect_domain_xml_from_native_ret),
(xdrproc_t)xdr_remote_connect_domain_xml_from_native_ret,
true,
0
},
{ /* Method ConnectDomainXMLToNative => 136 */
remoteDispatchConnectDomainXMLToNativeHelper,
sizeof(remote_connect_domain_xml_to_native_args),
(xdrproc_t)xdr_remote_connect_domain_xml_to_native_args,
sizeof(remote_connect_domain_xml_to_native_ret),
(xdrproc_t)xdr_remote_connect_domain_xml_to_native_ret,
true,
0
},
{ /* Method ConnectNumOfDefinedInterfaces => 137 */
remoteDispatchConnectNumOfDefinedInterfacesHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_defined_interfaces_ret),
(xdrproc_t)xdr_remote_connect_num_of_defined_interfaces_ret,
true,
1
},
{ /* Method ConnectListDefinedInterfaces => 138 */
remoteDispatchConnectListDefinedInterfacesHelper,
sizeof(remote_connect_list_defined_interfaces_args),
(xdrproc_t)xdr_remote_connect_list_defined_interfaces_args,
sizeof(remote_connect_list_defined_interfaces_ret),
(xdrproc_t)xdr_remote_connect_list_defined_interfaces_ret,
true,
1
},
{ /* Method ConnectNumOfSecrets => 139 */
remoteDispatchConnectNumOfSecretsHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_secrets_ret),
(xdrproc_t)xdr_remote_connect_num_of_secrets_ret,
true,
1
},
{ /* Method ConnectListSecrets => 140 */
remoteDispatchConnectListSecretsHelper,
sizeof(remote_connect_list_secrets_args),
(xdrproc_t)xdr_remote_connect_list_secrets_args,
sizeof(remote_connect_list_secrets_ret),
(xdrproc_t)xdr_remote_connect_list_secrets_ret,
true,
1
},
{ /* Method SecretLookupByUUID => 141 */
remoteDispatchSecretLookupByUUIDHelper,
sizeof(remote_secret_lookup_by_uuid_args),
(xdrproc_t)xdr_remote_secret_lookup_by_uuid_args,
sizeof(remote_secret_lookup_by_uuid_ret),
(xdrproc_t)xdr_remote_secret_lookup_by_uuid_ret,
true,
1
},
{ /* Method SecretDefineXML => 142 */
remoteDispatchSecretDefineXMLHelper,
sizeof(remote_secret_define_xml_args),
(xdrproc_t)xdr_remote_secret_define_xml_args,
sizeof(remote_secret_define_xml_ret),
(xdrproc_t)xdr_remote_secret_define_xml_ret,
true,
1
},
{ /* Method SecretGetXMLDesc => 143 */
remoteDispatchSecretGetXMLDescHelper,
sizeof(remote_secret_get_xml_desc_args),
(xdrproc_t)xdr_remote_secret_get_xml_desc_args,
sizeof(remote_secret_get_xml_desc_ret),
(xdrproc_t)xdr_remote_secret_get_xml_desc_ret,
true,
1
},
{ /* Method SecretSetValue => 144 */
remoteDispatchSecretSetValueHelper,
sizeof(remote_secret_set_value_args),
(xdrproc_t)xdr_remote_secret_set_value_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method SecretGetValue => 145 */
remoteDispatchSecretGetValueHelper,
sizeof(remote_secret_get_value_args),
(xdrproc_t)xdr_remote_secret_get_value_args,
sizeof(remote_secret_get_value_ret),
(xdrproc_t)xdr_remote_secret_get_value_ret,
true,
1
},
{ /* Method SecretUndefine => 146 */
remoteDispatchSecretUndefineHelper,
sizeof(remote_secret_undefine_args),
(xdrproc_t)xdr_remote_secret_undefine_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method SecretLookupByUsage => 147 */
remoteDispatchSecretLookupByUsageHelper,
sizeof(remote_secret_lookup_by_usage_args),
(xdrproc_t)xdr_remote_secret_lookup_by_usage_args,
sizeof(remote_secret_lookup_by_usage_ret),
(xdrproc_t)xdr_remote_secret_lookup_by_usage_ret,
true,
1
},
{ /* Method DomainMigratePrepareTunnel => 148 */
remoteDispatchDomainMigratePrepareTunnelHelper,
sizeof(remote_domain_migrate_prepare_tunnel_args),
(xdrproc_t)xdr_remote_domain_migrate_prepare_tunnel_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectIsSecure => 149 */
remoteDispatchConnectIsSecureHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_is_secure_ret),
(xdrproc_t)xdr_remote_connect_is_secure_ret,
true,
1
},
{ /* Method DomainIsActive => 150 */
remoteDispatchDomainIsActiveHelper,
sizeof(remote_domain_is_active_args),
(xdrproc_t)xdr_remote_domain_is_active_args,
sizeof(remote_domain_is_active_ret),
(xdrproc_t)xdr_remote_domain_is_active_ret,
true,
1
},
{ /* Method DomainIsPersistent => 151 */
remoteDispatchDomainIsPersistentHelper,
sizeof(remote_domain_is_persistent_args),
(xdrproc_t)xdr_remote_domain_is_persistent_args,
sizeof(remote_domain_is_persistent_ret),
(xdrproc_t)xdr_remote_domain_is_persistent_ret,
true,
1
},
{ /* Method NetworkIsActive => 152 */
remoteDispatchNetworkIsActiveHelper,
sizeof(remote_network_is_active_args),
(xdrproc_t)xdr_remote_network_is_active_args,
sizeof(remote_network_is_active_ret),
(xdrproc_t)xdr_remote_network_is_active_ret,
true,
1
},
{ /* Method NetworkIsPersistent => 153 */
remoteDispatchNetworkIsPersistentHelper,
sizeof(remote_network_is_persistent_args),
(xdrproc_t)xdr_remote_network_is_persistent_args,
sizeof(remote_network_is_persistent_ret),
(xdrproc_t)xdr_remote_network_is_persistent_ret,
true,
1
},
{ /* Method StoragePoolIsActive => 154 */
remoteDispatchStoragePoolIsActiveHelper,
sizeof(remote_storage_pool_is_active_args),
(xdrproc_t)xdr_remote_storage_pool_is_active_args,
sizeof(remote_storage_pool_is_active_ret),
(xdrproc_t)xdr_remote_storage_pool_is_active_ret,
true,
1
},
{ /* Method StoragePoolIsPersistent => 155 */
remoteDispatchStoragePoolIsPersistentHelper,
sizeof(remote_storage_pool_is_persistent_args),
(xdrproc_t)xdr_remote_storage_pool_is_persistent_args,
sizeof(remote_storage_pool_is_persistent_ret),
(xdrproc_t)xdr_remote_storage_pool_is_persistent_ret,
true,
1
},
{ /* Method InterfaceIsActive => 156 */
remoteDispatchInterfaceIsActiveHelper,
sizeof(remote_interface_is_active_args),
(xdrproc_t)xdr_remote_interface_is_active_args,
sizeof(remote_interface_is_active_ret),
(xdrproc_t)xdr_remote_interface_is_active_ret,
true,
1
},
{ /* Method ConnectGetLibVersion => 157 */
remoteDispatchConnectGetLibVersionHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_get_lib_version_ret),
(xdrproc_t)xdr_remote_connect_get_lib_version_ret,
true,
1
},
{ /* Method ConnectCompareCPU => 158 */
remoteDispatchConnectCompareCPUHelper,
sizeof(remote_connect_compare_cpu_args),
(xdrproc_t)xdr_remote_connect_compare_cpu_args,
sizeof(remote_connect_compare_cpu_ret),
(xdrproc_t)xdr_remote_connect_compare_cpu_ret,
true,
1
},
{ /* Method DomainMemoryStats => 159 */
remoteDispatchDomainMemoryStatsHelper,
sizeof(remote_domain_memory_stats_args),
(xdrproc_t)xdr_remote_domain_memory_stats_args,
sizeof(remote_domain_memory_stats_ret),
(xdrproc_t)xdr_remote_domain_memory_stats_ret,
true,
0
},
{ /* Method DomainAttachDeviceFlags => 160 */
remoteDispatchDomainAttachDeviceFlagsHelper,
sizeof(remote_domain_attach_device_flags_args),
(xdrproc_t)xdr_remote_domain_attach_device_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainDetachDeviceFlags => 161 */
remoteDispatchDomainDetachDeviceFlagsHelper,
sizeof(remote_domain_detach_device_flags_args),
(xdrproc_t)xdr_remote_domain_detach_device_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectBaselineCPU => 162 */
remoteDispatchConnectBaselineCPUHelper,
sizeof(remote_connect_baseline_cpu_args),
(xdrproc_t)xdr_remote_connect_baseline_cpu_args,
sizeof(remote_connect_baseline_cpu_ret),
(xdrproc_t)xdr_remote_connect_baseline_cpu_ret,
true,
0
},
{ /* Method DomainGetJobInfo => 163 */
remoteDispatchDomainGetJobInfoHelper,
sizeof(remote_domain_get_job_info_args),
(xdrproc_t)xdr_remote_domain_get_job_info_args,
sizeof(remote_domain_get_job_info_ret),
(xdrproc_t)xdr_remote_domain_get_job_info_ret,
true,
0
},
{ /* Method DomainAbortJob => 164 */
remoteDispatchDomainAbortJobHelper,
sizeof(remote_domain_abort_job_args),
(xdrproc_t)xdr_remote_domain_abort_job_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolWipe => 165 */
remoteDispatchStorageVolWipeHelper,
sizeof(remote_storage_vol_wipe_args),
(xdrproc_t)xdr_remote_storage_vol_wipe_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainMigrateSetMaxDowntime => 166 */
remoteDispatchDomainMigrateSetMaxDowntimeHelper,
sizeof(remote_domain_migrate_set_max_downtime_args),
(xdrproc_t)xdr_remote_domain_migrate_set_max_downtime_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectDomainEventRegisterAny => 167 */
remoteDispatchConnectDomainEventRegisterAnyHelper,
sizeof(remote_connect_domain_event_register_any_args),
(xdrproc_t)xdr_remote_connect_domain_event_register_any_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method ConnectDomainEventDeregisterAny => 168 */
remoteDispatchConnectDomainEventDeregisterAnyHelper,
sizeof(remote_connect_domain_event_deregister_any_args),
(xdrproc_t)xdr_remote_connect_domain_event_deregister_any_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Async event DomainEventReboot => 169 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventRtcChange => 170 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventWatchdog => 171 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventIoError => 172 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventGraphics => 173 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainUpdateDeviceFlags => 174 */
remoteDispatchDomainUpdateDeviceFlagsHelper,
sizeof(remote_domain_update_device_flags_args),
(xdrproc_t)xdr_remote_domain_update_device_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NWFilterLookupByName => 175 */
remoteDispatchNWFilterLookupByNameHelper,
sizeof(remote_nwfilter_lookup_by_name_args),
(xdrproc_t)xdr_remote_nwfilter_lookup_by_name_args,
sizeof(remote_nwfilter_lookup_by_name_ret),
(xdrproc_t)xdr_remote_nwfilter_lookup_by_name_ret,
true,
1
},
{ /* Method NWFilterLookupByUUID => 176 */
remoteDispatchNWFilterLookupByUUIDHelper,
sizeof(remote_nwfilter_lookup_by_uuid_args),
(xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_args,
sizeof(remote_nwfilter_lookup_by_uuid_ret),
(xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_ret,
true,
1
},
{ /* Method NWFilterGetXMLDesc => 177 */
remoteDispatchNWFilterGetXMLDescHelper,
sizeof(remote_nwfilter_get_xml_desc_args),
(xdrproc_t)xdr_remote_nwfilter_get_xml_desc_args,
sizeof(remote_nwfilter_get_xml_desc_ret),
(xdrproc_t)xdr_remote_nwfilter_get_xml_desc_ret,
true,
1
},
{ /* Method ConnectNumOfNWFilters => 178 */
remoteDispatchConnectNumOfNWFiltersHelper,
0,
(xdrproc_t)xdr_void,
sizeof(remote_connect_num_of_nwfilters_ret),
(xdrproc_t)xdr_remote_connect_num_of_nwfilters_ret,
true,
1
},
{ /* Method ConnectListNWFilters => 179 */
remoteDispatchConnectListNWFiltersHelper,
sizeof(remote_connect_list_nwfilters_args),
(xdrproc_t)xdr_remote_connect_list_nwfilters_args,
sizeof(remote_connect_list_nwfilters_ret),
(xdrproc_t)xdr_remote_connect_list_nwfilters_ret,
true,
1
},
{ /* Method NWFilterDefineXML => 180 */
remoteDispatchNWFilterDefineXMLHelper,
sizeof(remote_nwfilter_define_xml_args),
(xdrproc_t)xdr_remote_nwfilter_define_xml_args,
sizeof(remote_nwfilter_define_xml_ret),
(xdrproc_t)xdr_remote_nwfilter_define_xml_ret,
true,
1
},
{ /* Method NWFilterUndefine => 181 */
remoteDispatchNWFilterUndefineHelper,
sizeof(remote_nwfilter_undefine_args),
(xdrproc_t)xdr_remote_nwfilter_undefine_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainManagedSave => 182 */
remoteDispatchDomainManagedSaveHelper,
sizeof(remote_domain_managed_save_args),
(xdrproc_t)xdr_remote_domain_managed_save_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainHasManagedSaveImage => 183 */
remoteDispatchDomainHasManagedSaveImageHelper,
sizeof(remote_domain_has_managed_save_image_args),
(xdrproc_t)xdr_remote_domain_has_managed_save_image_args,
sizeof(remote_domain_has_managed_save_image_ret),
(xdrproc_t)xdr_remote_domain_has_managed_save_image_ret,
true,
0
},
{ /* Method DomainManagedSaveRemove => 184 */
remoteDispatchDomainManagedSaveRemoveHelper,
sizeof(remote_domain_managed_save_remove_args),
(xdrproc_t)xdr_remote_domain_managed_save_remove_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSnapshotCreateXML => 185 */
remoteDispatchDomainSnapshotCreateXMLHelper,
sizeof(remote_domain_snapshot_create_xml_args),
(xdrproc_t)xdr_remote_domain_snapshot_create_xml_args,
sizeof(remote_domain_snapshot_create_xml_ret),
(xdrproc_t)xdr_remote_domain_snapshot_create_xml_ret,
true,
0
},
{ /* Method DomainSnapshotGetXMLDesc => 186 */
remoteDispatchDomainSnapshotGetXMLDescHelper,
sizeof(remote_domain_snapshot_get_xml_desc_args),
(xdrproc_t)xdr_remote_domain_snapshot_get_xml_desc_args,
sizeof(remote_domain_snapshot_get_xml_desc_ret),
(xdrproc_t)xdr_remote_domain_snapshot_get_xml_desc_ret,
true,
1
},
{ /* Method DomainSnapshotNum => 187 */
remoteDispatchDomainSnapshotNumHelper,
sizeof(remote_domain_snapshot_num_args),
(xdrproc_t)xdr_remote_domain_snapshot_num_args,
sizeof(remote_domain_snapshot_num_ret),
(xdrproc_t)xdr_remote_domain_snapshot_num_ret,
true,
1
},
{ /* Method DomainSnapshotListNames => 188 */
remoteDispatchDomainSnapshotListNamesHelper,
sizeof(remote_domain_snapshot_list_names_args),
(xdrproc_t)xdr_remote_domain_snapshot_list_names_args,
sizeof(remote_domain_snapshot_list_names_ret),
(xdrproc_t)xdr_remote_domain_snapshot_list_names_ret,
true,
1
},
{ /* Method DomainSnapshotLookupByName => 189 */
remoteDispatchDomainSnapshotLookupByNameHelper,
sizeof(remote_domain_snapshot_lookup_by_name_args),
(xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_args,
sizeof(remote_domain_snapshot_lookup_by_name_ret),
(xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_ret,
true,
1
},
{ /* Method DomainHasCurrentSnapshot => 190 */
remoteDispatchDomainHasCurrentSnapshotHelper,
sizeof(remote_domain_has_current_snapshot_args),
(xdrproc_t)xdr_remote_domain_has_current_snapshot_args,
sizeof(remote_domain_has_current_snapshot_ret),
(xdrproc_t)xdr_remote_domain_has_current_snapshot_ret,
true,
0
},
{ /* Method DomainSnapshotCurrent => 191 */
remoteDispatchDomainSnapshotCurrentHelper,
sizeof(remote_domain_snapshot_current_args),
(xdrproc_t)xdr_remote_domain_snapshot_current_args,
sizeof(remote_domain_snapshot_current_ret),
(xdrproc_t)xdr_remote_domain_snapshot_current_ret,
true,
0
},
{ /* Method DomainRevertToSnapshot => 192 */
remoteDispatchDomainRevertToSnapshotHelper,
sizeof(remote_domain_revert_to_snapshot_args),
(xdrproc_t)xdr_remote_domain_revert_to_snapshot_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSnapshotDelete => 193 */
remoteDispatchDomainSnapshotDeleteHelper,
sizeof(remote_domain_snapshot_delete_args),
(xdrproc_t)xdr_remote_domain_snapshot_delete_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetBlockInfo => 194 */
remoteDispatchDomainGetBlockInfoHelper,
sizeof(remote_domain_get_block_info_args),
(xdrproc_t)xdr_remote_domain_get_block_info_args,
sizeof(remote_domain_get_block_info_ret),
(xdrproc_t)xdr_remote_domain_get_block_info_ret,
true,
0
},
{ /* Async event DomainEventIoErrorReason => 195 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainCreateWithFlags => 196 */
remoteDispatchDomainCreateWithFlagsHelper,
sizeof(remote_domain_create_with_flags_args),
(xdrproc_t)xdr_remote_domain_create_with_flags_args,
sizeof(remote_domain_create_with_flags_ret),
(xdrproc_t)xdr_remote_domain_create_with_flags_ret,
true,
0
},
{ /* Method DomainSetMemoryParameters => 197 */
remoteDispatchDomainSetMemoryParametersHelper,
sizeof(remote_domain_set_memory_parameters_args),
(xdrproc_t)xdr_remote_domain_set_memory_parameters_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetMemoryParameters => 198 */
remoteDispatchDomainGetMemoryParametersHelper,
sizeof(remote_domain_get_memory_parameters_args),
(xdrproc_t)xdr_remote_domain_get_memory_parameters_args,
sizeof(remote_domain_get_memory_parameters_ret),
(xdrproc_t)xdr_remote_domain_get_memory_parameters_ret,
true,
0
},
{ /* Method DomainSetVcpusFlags => 199 */
remoteDispatchDomainSetVcpusFlagsHelper,
sizeof(remote_domain_set_vcpus_flags_args),
(xdrproc_t)xdr_remote_domain_set_vcpus_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetVcpusFlags => 200 */
remoteDispatchDomainGetVcpusFlagsHelper,
sizeof(remote_domain_get_vcpus_flags_args),
(xdrproc_t)xdr_remote_domain_get_vcpus_flags_args,
sizeof(remote_domain_get_vcpus_flags_ret),
(xdrproc_t)xdr_remote_domain_get_vcpus_flags_ret,
true,
0
},
{ /* Method DomainOpenConsole => 201 */
remoteDispatchDomainOpenConsoleHelper,
sizeof(remote_domain_open_console_args),
(xdrproc_t)xdr_remote_domain_open_console_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainIsUpdated => 202 */
remoteDispatchDomainIsUpdatedHelper,
sizeof(remote_domain_is_updated_args),
(xdrproc_t)xdr_remote_domain_is_updated_args,
sizeof(remote_domain_is_updated_ret),
(xdrproc_t)xdr_remote_domain_is_updated_ret,
true,
1
},
{ /* Method ConnectGetSysinfo => 203 */
remoteDispatchConnectGetSysinfoHelper,
sizeof(remote_connect_get_sysinfo_args),
(xdrproc_t)xdr_remote_connect_get_sysinfo_args,
sizeof(remote_connect_get_sysinfo_ret),
(xdrproc_t)xdr_remote_connect_get_sysinfo_ret,
true,
1
},
{ /* Method DomainSetMemoryFlags => 204 */
remoteDispatchDomainSetMemoryFlagsHelper,
sizeof(remote_domain_set_memory_flags_args),
(xdrproc_t)xdr_remote_domain_set_memory_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSetBlkioParameters => 205 */
remoteDispatchDomainSetBlkioParametersHelper,
sizeof(remote_domain_set_blkio_parameters_args),
(xdrproc_t)xdr_remote_domain_set_blkio_parameters_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetBlkioParameters => 206 */
remoteDispatchDomainGetBlkioParametersHelper,
sizeof(remote_domain_get_blkio_parameters_args),
(xdrproc_t)xdr_remote_domain_get_blkio_parameters_args,
sizeof(remote_domain_get_blkio_parameters_ret),
(xdrproc_t)xdr_remote_domain_get_blkio_parameters_ret,
true,
0
},
{ /* Method DomainMigrateSetMaxSpeed => 207 */
remoteDispatchDomainMigrateSetMaxSpeedHelper,
sizeof(remote_domain_migrate_set_max_speed_args),
(xdrproc_t)xdr_remote_domain_migrate_set_max_speed_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolUpload => 208 */
remoteDispatchStorageVolUploadHelper,
sizeof(remote_storage_vol_upload_args),
(xdrproc_t)xdr_remote_storage_vol_upload_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolDownload => 209 */
remoteDispatchStorageVolDownloadHelper,
sizeof(remote_storage_vol_download_args),
(xdrproc_t)xdr_remote_storage_vol_download_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainInjectNMI => 210 */
remoteDispatchDomainInjectNMIHelper,
sizeof(remote_domain_inject_nmi_args),
(xdrproc_t)xdr_remote_domain_inject_nmi_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainScreenshot => 211 */
remoteDispatchDomainScreenshotHelper,
sizeof(remote_domain_screenshot_args),
(xdrproc_t)xdr_remote_domain_screenshot_args,
sizeof(remote_domain_screenshot_ret),
(xdrproc_t)xdr_remote_domain_screenshot_ret,
true,
0
},
{ /* Method DomainGetState => 212 */
remoteDispatchDomainGetStateHelper,
sizeof(remote_domain_get_state_args),
(xdrproc_t)xdr_remote_domain_get_state_args,
sizeof(remote_domain_get_state_ret),
(xdrproc_t)xdr_remote_domain_get_state_ret,
true,
1
},
{ /* Method DomainMigrateBegin3 => 213 */
remoteDispatchDomainMigrateBegin3Helper,
sizeof(remote_domain_migrate_begin3_args),
(xdrproc_t)xdr_remote_domain_migrate_begin3_args,
sizeof(remote_domain_migrate_begin3_ret),
(xdrproc_t)xdr_remote_domain_migrate_begin3_ret,
true,
0
},
{ /* Method DomainMigratePrepare3 => 214 */
remoteDispatchDomainMigratePrepare3Helper,
sizeof(remote_domain_migrate_prepare3_args),
(xdrproc_t)xdr_remote_domain_migrate_prepare3_args,
sizeof(remote_domain_migrate_prepare3_ret),
(xdrproc_t)xdr_remote_domain_migrate_prepare3_ret,
true,
0
},
{ /* Method DomainMigratePrepareTunnel3 => 215 */
remoteDispatchDomainMigratePrepareTunnel3Helper,
sizeof(remote_domain_migrate_prepare_tunnel3_args),
(xdrproc_t)xdr_remote_domain_migrate_prepare_tunnel3_args,
sizeof(remote_domain_migrate_prepare_tunnel3_ret),
(xdrproc_t)xdr_remote_domain_migrate_prepare_tunnel3_ret,
true,
0
},
{ /* Method DomainMigratePerform3 => 216 */
remoteDispatchDomainMigratePerform3Helper,
sizeof(remote_domain_migrate_perform3_args),
(xdrproc_t)xdr_remote_domain_migrate_perform3_args,
sizeof(remote_domain_migrate_perform3_ret),
(xdrproc_t)xdr_remote_domain_migrate_perform3_ret,
true,
0
},
{ /* Method DomainMigrateFinish3 => 217 */
remoteDispatchDomainMigrateFinish3Helper,
sizeof(remote_domain_migrate_finish3_args),
(xdrproc_t)xdr_remote_domain_migrate_finish3_args,
sizeof(remote_domain_migrate_finish3_ret),
(xdrproc_t)xdr_remote_domain_migrate_finish3_ret,
true,
0
},
{ /* Method DomainMigrateConfirm3 => 218 */
remoteDispatchDomainMigrateConfirm3Helper,
sizeof(remote_domain_migrate_confirm3_args),
(xdrproc_t)xdr_remote_domain_migrate_confirm3_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSetSchedulerParametersFlags => 219 */
remoteDispatchDomainSetSchedulerParametersFlagsHelper,
sizeof(remote_domain_set_scheduler_parameters_flags_args),
(xdrproc_t)xdr_remote_domain_set_scheduler_parameters_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method InterfaceChangeBegin => 220 */
remoteDispatchInterfaceChangeBeginHelper,
sizeof(remote_interface_change_begin_args),
(xdrproc_t)xdr_remote_interface_change_begin_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method InterfaceChangeCommit => 221 */
remoteDispatchInterfaceChangeCommitHelper,
sizeof(remote_interface_change_commit_args),
(xdrproc_t)xdr_remote_interface_change_commit_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method InterfaceChangeRollback => 222 */
remoteDispatchInterfaceChangeRollbackHelper,
sizeof(remote_interface_change_rollback_args),
(xdrproc_t)xdr_remote_interface_change_rollback_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetSchedulerParametersFlags => 223 */
remoteDispatchDomainGetSchedulerParametersFlagsHelper,
sizeof(remote_domain_get_scheduler_parameters_flags_args),
(xdrproc_t)xdr_remote_domain_get_scheduler_parameters_flags_args,
sizeof(remote_domain_get_scheduler_parameters_flags_ret),
(xdrproc_t)xdr_remote_domain_get_scheduler_parameters_flags_ret,
true,
0
},
{ /* Async event DomainEventControlError => 224 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainPinVcpuFlags => 225 */
remoteDispatchDomainPinVcpuFlagsHelper,
sizeof(remote_domain_pin_vcpu_flags_args),
(xdrproc_t)xdr_remote_domain_pin_vcpu_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSendKey => 226 */
remoteDispatchDomainSendKeyHelper,
sizeof(remote_domain_send_key_args),
(xdrproc_t)xdr_remote_domain_send_key_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeGetCPUStats => 227 */
remoteDispatchNodeGetCPUStatsHelper,
sizeof(remote_node_get_cpu_stats_args),
(xdrproc_t)xdr_remote_node_get_cpu_stats_args,
sizeof(remote_node_get_cpu_stats_ret),
(xdrproc_t)xdr_remote_node_get_cpu_stats_ret,
true,
1
},
{ /* Method NodeGetMemoryStats => 228 */
remoteDispatchNodeGetMemoryStatsHelper,
sizeof(remote_node_get_memory_stats_args),
(xdrproc_t)xdr_remote_node_get_memory_stats_args,
sizeof(remote_node_get_memory_stats_ret),
(xdrproc_t)xdr_remote_node_get_memory_stats_ret,
true,
1
},
{ /* Method DomainGetControlInfo => 229 */
remoteDispatchDomainGetControlInfoHelper,
sizeof(remote_domain_get_control_info_args),
(xdrproc_t)xdr_remote_domain_get_control_info_args,
sizeof(remote_domain_get_control_info_ret),
(xdrproc_t)xdr_remote_domain_get_control_info_ret,
true,
1
},
{ /* Method DomainGetVcpuPinInfo => 230 */
remoteDispatchDomainGetVcpuPinInfoHelper,
sizeof(remote_domain_get_vcpu_pin_info_args),
(xdrproc_t)xdr_remote_domain_get_vcpu_pin_info_args,
sizeof(remote_domain_get_vcpu_pin_info_ret),
(xdrproc_t)xdr_remote_domain_get_vcpu_pin_info_ret,
true,
0
},
{ /* Method DomainUndefineFlags => 231 */
remoteDispatchDomainUndefineFlagsHelper,
sizeof(remote_domain_undefine_flags_args),
(xdrproc_t)xdr_remote_domain_undefine_flags_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainSaveFlags => 232 */
remoteDispatchDomainSaveFlagsHelper,
sizeof(remote_domain_save_flags_args),
(xdrproc_t)xdr_remote_domain_save_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainRestoreFlags => 233 */
remoteDispatchDomainRestoreFlagsHelper,
sizeof(remote_domain_restore_flags_args),
(xdrproc_t)xdr_remote_domain_restore_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainDestroyFlags => 234 */
remoteDispatchDomainDestroyFlagsHelper,
sizeof(remote_domain_destroy_flags_args),
(xdrproc_t)xdr_remote_domain_destroy_flags_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainSaveImageGetXMLDesc => 235 */
remoteDispatchDomainSaveImageGetXMLDescHelper,
sizeof(remote_domain_save_image_get_xml_desc_args),
(xdrproc_t)xdr_remote_domain_save_image_get_xml_desc_args,
sizeof(remote_domain_save_image_get_xml_desc_ret),
(xdrproc_t)xdr_remote_domain_save_image_get_xml_desc_ret,
true,
1
},
{ /* Method DomainSaveImageDefineXML => 236 */
remoteDispatchDomainSaveImageDefineXMLHelper,
sizeof(remote_domain_save_image_define_xml_args),
(xdrproc_t)xdr_remote_domain_save_image_define_xml_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainBlockJobAbort => 237 */
remoteDispatchDomainBlockJobAbortHelper,
sizeof(remote_domain_block_job_abort_args),
(xdrproc_t)xdr_remote_domain_block_job_abort_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetBlockJobInfo => 238 */
remoteDispatchDomainGetBlockJobInfoHelper,
sizeof(remote_domain_get_block_job_info_args),
(xdrproc_t)xdr_remote_domain_get_block_job_info_args,
sizeof(remote_domain_get_block_job_info_ret),
(xdrproc_t)xdr_remote_domain_get_block_job_info_ret,
true,
0
},
{ /* Method DomainBlockJobSetSpeed => 239 */
remoteDispatchDomainBlockJobSetSpeedHelper,
sizeof(remote_domain_block_job_set_speed_args),
(xdrproc_t)xdr_remote_domain_block_job_set_speed_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainBlockPull => 240 */
remoteDispatchDomainBlockPullHelper,
sizeof(remote_domain_block_pull_args),
(xdrproc_t)xdr_remote_domain_block_pull_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventBlockJob => 241 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainMigrateGetMaxSpeed => 242 */
remoteDispatchDomainMigrateGetMaxSpeedHelper,
sizeof(remote_domain_migrate_get_max_speed_args),
(xdrproc_t)xdr_remote_domain_migrate_get_max_speed_args,
sizeof(remote_domain_migrate_get_max_speed_ret),
(xdrproc_t)xdr_remote_domain_migrate_get_max_speed_ret,
true,
0
},
{ /* Method DomainBlockStatsFlags => 243 */
remoteDispatchDomainBlockStatsFlagsHelper,
sizeof(remote_domain_block_stats_flags_args),
(xdrproc_t)xdr_remote_domain_block_stats_flags_args,
sizeof(remote_domain_block_stats_flags_ret),
(xdrproc_t)xdr_remote_domain_block_stats_flags_ret,
true,
0
},
{ /* Method DomainSnapshotGetParent => 244 */
remoteDispatchDomainSnapshotGetParentHelper,
sizeof(remote_domain_snapshot_get_parent_args),
(xdrproc_t)xdr_remote_domain_snapshot_get_parent_args,
sizeof(remote_domain_snapshot_get_parent_ret),
(xdrproc_t)xdr_remote_domain_snapshot_get_parent_ret,
true,
1
},
{ /* Method DomainReset => 245 */
remoteDispatchDomainResetHelper,
sizeof(remote_domain_reset_args),
(xdrproc_t)xdr_remote_domain_reset_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSnapshotNumChildren => 246 */
remoteDispatchDomainSnapshotNumChildrenHelper,
sizeof(remote_domain_snapshot_num_children_args),
(xdrproc_t)xdr_remote_domain_snapshot_num_children_args,
sizeof(remote_domain_snapshot_num_children_ret),
(xdrproc_t)xdr_remote_domain_snapshot_num_children_ret,
true,
1
},
{ /* Method DomainSnapshotListChildrenNames => 247 */
remoteDispatchDomainSnapshotListChildrenNamesHelper,
sizeof(remote_domain_snapshot_list_children_names_args),
(xdrproc_t)xdr_remote_domain_snapshot_list_children_names_args,
sizeof(remote_domain_snapshot_list_children_names_ret),
(xdrproc_t)xdr_remote_domain_snapshot_list_children_names_ret,
true,
1
},
{ /* Async event DomainEventDiskChange => 248 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainOpenGraphics => 249 */
remoteDispatchDomainOpenGraphicsHelper,
sizeof(remote_domain_open_graphics_args),
(xdrproc_t)xdr_remote_domain_open_graphics_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeSuspendForDuration => 250 */
remoteDispatchNodeSuspendForDurationHelper,
sizeof(remote_node_suspend_for_duration_args),
(xdrproc_t)xdr_remote_node_suspend_for_duration_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainBlockResize => 251 */
remoteDispatchDomainBlockResizeHelper,
sizeof(remote_domain_block_resize_args),
(xdrproc_t)xdr_remote_domain_block_resize_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSetBlockIoTune => 252 */
remoteDispatchDomainSetBlockIoTuneHelper,
sizeof(remote_domain_set_block_io_tune_args),
(xdrproc_t)xdr_remote_domain_set_block_io_tune_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetBlockIoTune => 253 */
remoteDispatchDomainGetBlockIoTuneHelper,
sizeof(remote_domain_get_block_io_tune_args),
(xdrproc_t)xdr_remote_domain_get_block_io_tune_args,
sizeof(remote_domain_get_block_io_tune_ret),
(xdrproc_t)xdr_remote_domain_get_block_io_tune_ret,
true,
0
},
{ /* Method DomainSetNumaParameters => 254 */
remoteDispatchDomainSetNumaParametersHelper,
sizeof(remote_domain_set_numa_parameters_args),
(xdrproc_t)xdr_remote_domain_set_numa_parameters_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetNumaParameters => 255 */
remoteDispatchDomainGetNumaParametersHelper,
sizeof(remote_domain_get_numa_parameters_args),
(xdrproc_t)xdr_remote_domain_get_numa_parameters_args,
sizeof(remote_domain_get_numa_parameters_ret),
(xdrproc_t)xdr_remote_domain_get_numa_parameters_ret,
true,
0
},
{ /* Method DomainSetInterfaceParameters => 256 */
remoteDispatchDomainSetInterfaceParametersHelper,
sizeof(remote_domain_set_interface_parameters_args),
(xdrproc_t)xdr_remote_domain_set_interface_parameters_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetInterfaceParameters => 257 */
remoteDispatchDomainGetInterfaceParametersHelper,
sizeof(remote_domain_get_interface_parameters_args),
(xdrproc_t)xdr_remote_domain_get_interface_parameters_args,
sizeof(remote_domain_get_interface_parameters_ret),
(xdrproc_t)xdr_remote_domain_get_interface_parameters_ret,
true,
0
},
{ /* Method DomainShutdownFlags => 258 */
remoteDispatchDomainShutdownFlagsHelper,
sizeof(remote_domain_shutdown_flags_args),
(xdrproc_t)xdr_remote_domain_shutdown_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolWipePattern => 259 */
remoteDispatchStorageVolWipePatternHelper,
sizeof(remote_storage_vol_wipe_pattern_args),
(xdrproc_t)xdr_remote_storage_vol_wipe_pattern_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolResize => 260 */
remoteDispatchStorageVolResizeHelper,
sizeof(remote_storage_vol_resize_args),
(xdrproc_t)xdr_remote_storage_vol_resize_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainPMSuspendForDuration => 261 */
remoteDispatchDomainPMSuspendForDurationHelper,
sizeof(remote_domain_pm_suspend_for_duration_args),
(xdrproc_t)xdr_remote_domain_pm_suspend_for_duration_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetCPUStats => 262 */
remoteDispatchDomainGetCPUStatsHelper,
sizeof(remote_domain_get_cpu_stats_args),
(xdrproc_t)xdr_remote_domain_get_cpu_stats_args,
sizeof(remote_domain_get_cpu_stats_ret),
(xdrproc_t)xdr_remote_domain_get_cpu_stats_ret,
true,
0
},
{ /* Method DomainGetDiskErrors => 263 */
remoteDispatchDomainGetDiskErrorsHelper,
sizeof(remote_domain_get_disk_errors_args),
(xdrproc_t)xdr_remote_domain_get_disk_errors_args,
sizeof(remote_domain_get_disk_errors_ret),
(xdrproc_t)xdr_remote_domain_get_disk_errors_ret,
true,
0
},
{ /* Method DomainSetMetadata => 264 */
remoteDispatchDomainSetMetadataHelper,
sizeof(remote_domain_set_metadata_args),
(xdrproc_t)xdr_remote_domain_set_metadata_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetMetadata => 265 */
remoteDispatchDomainGetMetadataHelper,
sizeof(remote_domain_get_metadata_args),
(xdrproc_t)xdr_remote_domain_get_metadata_args,
sizeof(remote_domain_get_metadata_ret),
(xdrproc_t)xdr_remote_domain_get_metadata_ret,
true,
0
},
{ /* Method DomainBlockRebase => 266 */
remoteDispatchDomainBlockRebaseHelper,
sizeof(remote_domain_block_rebase_args),
(xdrproc_t)xdr_remote_domain_block_rebase_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainPMWakeup => 267 */
remoteDispatchDomainPMWakeupHelper,
sizeof(remote_domain_pm_wakeup_args),
(xdrproc_t)xdr_remote_domain_pm_wakeup_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventTrayChange => 268 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventPMwakeup => 269 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventPMsuspend => 270 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSnapshotIsCurrent => 271 */
remoteDispatchDomainSnapshotIsCurrentHelper,
sizeof(remote_domain_snapshot_is_current_args),
(xdrproc_t)xdr_remote_domain_snapshot_is_current_args,
sizeof(remote_domain_snapshot_is_current_ret),
(xdrproc_t)xdr_remote_domain_snapshot_is_current_ret,
true,
0
},
{ /* Method DomainSnapshotHasMetadata => 272 */
remoteDispatchDomainSnapshotHasMetadataHelper,
sizeof(remote_domain_snapshot_has_metadata_args),
(xdrproc_t)xdr_remote_domain_snapshot_has_metadata_args,
sizeof(remote_domain_snapshot_has_metadata_ret),
(xdrproc_t)xdr_remote_domain_snapshot_has_metadata_ret,
true,
0
},
{ /* Method ConnectListAllDomains => 273 */
remoteDispatchConnectListAllDomainsHelper,
sizeof(remote_connect_list_all_domains_args),
(xdrproc_t)xdr_remote_connect_list_all_domains_args,
sizeof(remote_connect_list_all_domains_ret),
(xdrproc_t)xdr_remote_connect_list_all_domains_ret,
true,
1
},
{ /* Method DomainListAllSnapshots => 274 */
remoteDispatchDomainListAllSnapshotsHelper,
sizeof(remote_domain_list_all_snapshots_args),
(xdrproc_t)xdr_remote_domain_list_all_snapshots_args,
sizeof(remote_domain_list_all_snapshots_ret),
(xdrproc_t)xdr_remote_domain_list_all_snapshots_ret,
true,
1
},
{ /* Method DomainSnapshotListAllChildren => 275 */
remoteDispatchDomainSnapshotListAllChildrenHelper,
sizeof(remote_domain_snapshot_list_all_children_args),
(xdrproc_t)xdr_remote_domain_snapshot_list_all_children_args,
sizeof(remote_domain_snapshot_list_all_children_ret),
(xdrproc_t)xdr_remote_domain_snapshot_list_all_children_ret,
true,
1
},
{ /* Async event DomainEventBalloonChange => 276 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetHostname => 277 */
remoteDispatchDomainGetHostnameHelper,
sizeof(remote_domain_get_hostname_args),
(xdrproc_t)xdr_remote_domain_get_hostname_args,
sizeof(remote_domain_get_hostname_ret),
(xdrproc_t)xdr_remote_domain_get_hostname_ret,
true,
0
},
{ /* Method DomainGetSecurityLabelList => 278 */
remoteDispatchDomainGetSecurityLabelListHelper,
sizeof(remote_domain_get_security_label_list_args),
(xdrproc_t)xdr_remote_domain_get_security_label_list_args,
sizeof(remote_domain_get_security_label_list_ret),
(xdrproc_t)xdr_remote_domain_get_security_label_list_ret,
true,
1
},
{ /* Method DomainPinEmulator => 279 */
remoteDispatchDomainPinEmulatorHelper,
sizeof(remote_domain_pin_emulator_args),
(xdrproc_t)xdr_remote_domain_pin_emulator_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetEmulatorPinInfo => 280 */
remoteDispatchDomainGetEmulatorPinInfoHelper,
sizeof(remote_domain_get_emulator_pin_info_args),
(xdrproc_t)xdr_remote_domain_get_emulator_pin_info_args,
sizeof(remote_domain_get_emulator_pin_info_ret),
(xdrproc_t)xdr_remote_domain_get_emulator_pin_info_ret,
true,
0
},
{ /* Method ConnectListAllStoragePools => 281 */
remoteDispatchConnectListAllStoragePoolsHelper,
sizeof(remote_connect_list_all_storage_pools_args),
(xdrproc_t)xdr_remote_connect_list_all_storage_pools_args,
sizeof(remote_connect_list_all_storage_pools_ret),
(xdrproc_t)xdr_remote_connect_list_all_storage_pools_ret,
true,
1
},
{ /* Method StoragePoolListAllVolumes => 282 */
remoteDispatchStoragePoolListAllVolumesHelper,
sizeof(remote_storage_pool_list_all_volumes_args),
(xdrproc_t)xdr_remote_storage_pool_list_all_volumes_args,
sizeof(remote_storage_pool_list_all_volumes_ret),
(xdrproc_t)xdr_remote_storage_pool_list_all_volumes_ret,
true,
1
},
{ /* Method ConnectListAllNetworks => 283 */
remoteDispatchConnectListAllNetworksHelper,
sizeof(remote_connect_list_all_networks_args),
(xdrproc_t)xdr_remote_connect_list_all_networks_args,
sizeof(remote_connect_list_all_networks_ret),
(xdrproc_t)xdr_remote_connect_list_all_networks_ret,
true,
1
},
{ /* Method ConnectListAllInterfaces => 284 */
remoteDispatchConnectListAllInterfacesHelper,
sizeof(remote_connect_list_all_interfaces_args),
(xdrproc_t)xdr_remote_connect_list_all_interfaces_args,
sizeof(remote_connect_list_all_interfaces_ret),
(xdrproc_t)xdr_remote_connect_list_all_interfaces_ret,
true,
1
},
{ /* Method ConnectListAllNodeDevices => 285 */
remoteDispatchConnectListAllNodeDevicesHelper,
sizeof(remote_connect_list_all_node_devices_args),
(xdrproc_t)xdr_remote_connect_list_all_node_devices_args,
sizeof(remote_connect_list_all_node_devices_ret),
(xdrproc_t)xdr_remote_connect_list_all_node_devices_ret,
true,
1
},
{ /* Method ConnectListAllNWFilters => 286 */
remoteDispatchConnectListAllNWFiltersHelper,
sizeof(remote_connect_list_all_nwfilters_args),
(xdrproc_t)xdr_remote_connect_list_all_nwfilters_args,
sizeof(remote_connect_list_all_nwfilters_ret),
(xdrproc_t)xdr_remote_connect_list_all_nwfilters_ret,
true,
1
},
{ /* Method ConnectListAllSecrets => 287 */
remoteDispatchConnectListAllSecretsHelper,
sizeof(remote_connect_list_all_secrets_args),
(xdrproc_t)xdr_remote_connect_list_all_secrets_args,
sizeof(remote_connect_list_all_secrets_ret),
(xdrproc_t)xdr_remote_connect_list_all_secrets_ret,
true,
1
},
{ /* Method NodeSetMemoryParameters => 288 */
remoteDispatchNodeSetMemoryParametersHelper,
sizeof(remote_node_set_memory_parameters_args),
(xdrproc_t)xdr_remote_node_set_memory_parameters_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeGetMemoryParameters => 289 */
remoteDispatchNodeGetMemoryParametersHelper,
sizeof(remote_node_get_memory_parameters_args),
(xdrproc_t)xdr_remote_node_get_memory_parameters_args,
sizeof(remote_node_get_memory_parameters_ret),
(xdrproc_t)xdr_remote_node_get_memory_parameters_ret,
true,
0
},
{ /* Method DomainBlockCommit => 290 */
remoteDispatchDomainBlockCommitHelper,
sizeof(remote_domain_block_commit_args),
(xdrproc_t)xdr_remote_domain_block_commit_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NetworkUpdate => 291 */
remoteDispatchNetworkUpdateHelper,
sizeof(remote_network_update_args),
(xdrproc_t)xdr_remote_network_update_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Async event DomainEventPMsuspendDisk => 292 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeGetCPUMap => 293 */
remoteDispatchNodeGetCPUMapHelper,
sizeof(remote_node_get_cpu_map_args),
(xdrproc_t)xdr_remote_node_get_cpu_map_args,
sizeof(remote_node_get_cpu_map_ret),
(xdrproc_t)xdr_remote_node_get_cpu_map_ret,
true,
0
},
{ /* Method DomainFSTrim => 294 */
remoteDispatchDomainFSTrimHelper,
sizeof(remote_domain_fstrim_args),
(xdrproc_t)xdr_remote_domain_fstrim_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSendProcessSignal => 295 */
remoteDispatchDomainSendProcessSignalHelper,
sizeof(remote_domain_send_process_signal_args),
(xdrproc_t)xdr_remote_domain_send_process_signal_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainOpenChannel => 296 */
remoteDispatchDomainOpenChannelHelper,
sizeof(remote_domain_open_channel_args),
(xdrproc_t)xdr_remote_domain_open_channel_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeDeviceLookupSCSIHostByWWN => 297 */
remoteDispatchNodeDeviceLookupSCSIHostByWWNHelper,
sizeof(remote_node_device_lookup_scsi_host_by_wwn_args),
(xdrproc_t)xdr_remote_node_device_lookup_scsi_host_by_wwn_args,
sizeof(remote_node_device_lookup_scsi_host_by_wwn_ret),
(xdrproc_t)xdr_remote_node_device_lookup_scsi_host_by_wwn_ret,
true,
1
},
{ /* Method DomainGetJobStats => 298 */
remoteDispatchDomainGetJobStatsHelper,
sizeof(remote_domain_get_job_stats_args),
(xdrproc_t)xdr_remote_domain_get_job_stats_args,
sizeof(remote_domain_get_job_stats_ret),
(xdrproc_t)xdr_remote_domain_get_job_stats_ret,
true,
0
},
{ /* Method DomainMigrateGetCompressionCache => 299 */
remoteDispatchDomainMigrateGetCompressionCacheHelper,
sizeof(remote_domain_migrate_get_compression_cache_args),
(xdrproc_t)xdr_remote_domain_migrate_get_compression_cache_args,
sizeof(remote_domain_migrate_get_compression_cache_ret),
(xdrproc_t)xdr_remote_domain_migrate_get_compression_cache_ret,
true,
0
},
{ /* Method DomainMigrateSetCompressionCache => 300 */
remoteDispatchDomainMigrateSetCompressionCacheHelper,
sizeof(remote_domain_migrate_set_compression_cache_args),
(xdrproc_t)xdr_remote_domain_migrate_set_compression_cache_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeDeviceDetachFlags => 301 */
remoteDispatchNodeDeviceDetachFlagsHelper,
sizeof(remote_node_device_detach_flags_args),
(xdrproc_t)xdr_remote_node_device_detach_flags_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainMigrateBegin3Params => 302 */
remoteDispatchDomainMigrateBegin3ParamsHelper,
sizeof(remote_domain_migrate_begin3_params_args),
(xdrproc_t)xdr_remote_domain_migrate_begin3_params_args,
sizeof(remote_domain_migrate_begin3_params_ret),
(xdrproc_t)xdr_remote_domain_migrate_begin3_params_ret,
true,
0
},
{ /* Method DomainMigratePrepare3Params => 303 */
remoteDispatchDomainMigratePrepare3ParamsHelper,
sizeof(remote_domain_migrate_prepare3_params_args),
(xdrproc_t)xdr_remote_domain_migrate_prepare3_params_args,
sizeof(remote_domain_migrate_prepare3_params_ret),
(xdrproc_t)xdr_remote_domain_migrate_prepare3_params_ret,
true,
0
},
{ /* Method DomainMigratePrepareTunnel3Params => 304 */
remoteDispatchDomainMigratePrepareTunnel3ParamsHelper,
sizeof(remote_domain_migrate_prepare_tunnel3_params_args),
(xdrproc_t)xdr_remote_domain_migrate_prepare_tunnel3_params_args,
sizeof(remote_domain_migrate_prepare_tunnel3_params_ret),
(xdrproc_t)xdr_remote_domain_migrate_prepare_tunnel3_params_ret,
true,
0
},
{ /* Method DomainMigratePerform3Params => 305 */
remoteDispatchDomainMigratePerform3ParamsHelper,
sizeof(remote_domain_migrate_perform3_params_args),
(xdrproc_t)xdr_remote_domain_migrate_perform3_params_args,
sizeof(remote_domain_migrate_perform3_params_ret),
(xdrproc_t)xdr_remote_domain_migrate_perform3_params_ret,
true,
0
},
{ /* Method DomainMigrateFinish3Params => 306 */
remoteDispatchDomainMigrateFinish3ParamsHelper,
sizeof(remote_domain_migrate_finish3_params_args),
(xdrproc_t)xdr_remote_domain_migrate_finish3_params_args,
sizeof(remote_domain_migrate_finish3_params_ret),
(xdrproc_t)xdr_remote_domain_migrate_finish3_params_ret,
true,
0
},
{ /* Method DomainMigrateConfirm3Params => 307 */
remoteDispatchDomainMigrateConfirm3ParamsHelper,
sizeof(remote_domain_migrate_confirm3_params_args),
(xdrproc_t)xdr_remote_domain_migrate_confirm3_params_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSetMemoryStatsPeriod => 308 */
remoteDispatchDomainSetMemoryStatsPeriodHelper,
sizeof(remote_domain_set_memory_stats_period_args),
(xdrproc_t)xdr_remote_domain_set_memory_stats_period_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainCreateXMLWithFiles => 309 */
remoteDispatchDomainCreateXMLWithFilesHelper,
sizeof(remote_domain_create_xml_with_files_args),
(xdrproc_t)xdr_remote_domain_create_xml_with_files_args,
sizeof(remote_domain_create_xml_with_files_ret),
(xdrproc_t)xdr_remote_domain_create_xml_with_files_ret,
true,
0
},
{ /* Method DomainCreateWithFiles => 310 */
remoteDispatchDomainCreateWithFilesHelper,
sizeof(remote_domain_create_with_files_args),
(xdrproc_t)xdr_remote_domain_create_with_files_args,
sizeof(remote_domain_create_with_files_ret),
(xdrproc_t)xdr_remote_domain_create_with_files_ret,
true,
0
},
{ /* Async event DomainEventDeviceRemoved => 311 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectGetCPUModelNames => 312 */
remoteDispatchConnectGetCPUModelNamesHelper,
sizeof(remote_connect_get_cpu_model_names_args),
(xdrproc_t)xdr_remote_connect_get_cpu_model_names_args,
sizeof(remote_connect_get_cpu_model_names_ret),
(xdrproc_t)xdr_remote_connect_get_cpu_model_names_ret,
true,
0
},
{ /* Method ConnectNetworkEventRegisterAny => 313 */
remoteDispatchConnectNetworkEventRegisterAnyHelper,
sizeof(remote_connect_network_event_register_any_args),
(xdrproc_t)xdr_remote_connect_network_event_register_any_args,
sizeof(remote_connect_network_event_register_any_ret),
(xdrproc_t)xdr_remote_connect_network_event_register_any_ret,
true,
1
},
{ /* Method ConnectNetworkEventDeregisterAny => 314 */
remoteDispatchConnectNetworkEventDeregisterAnyHelper,
sizeof(remote_connect_network_event_deregister_any_args),
(xdrproc_t)xdr_remote_connect_network_event_deregister_any_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Async event NetworkEventLifecycle => 315 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectDomainEventCallbackRegisterAny => 316 */
remoteDispatchConnectDomainEventCallbackRegisterAnyHelper,
sizeof(remote_connect_domain_event_callback_register_any_args),
(xdrproc_t)xdr_remote_connect_domain_event_callback_register_any_args,
sizeof(remote_connect_domain_event_callback_register_any_ret),
(xdrproc_t)xdr_remote_connect_domain_event_callback_register_any_ret,
true,
1
},
{ /* Method ConnectDomainEventCallbackDeregisterAny => 317 */
remoteDispatchConnectDomainEventCallbackDeregisterAnyHelper,
sizeof(remote_connect_domain_event_callback_deregister_any_args),
(xdrproc_t)xdr_remote_connect_domain_event_callback_deregister_any_args,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Async event DomainEventCallbackLifecycle => 318 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackReboot => 319 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackRtcChange => 320 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackWatchdog => 321 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackIoError => 322 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackGraphics => 323 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackIoErrorReason => 324 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackControlError => 325 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackBlockJob => 326 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackDiskChange => 327 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackTrayChange => 328 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackPMwakeup => 329 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackPMsuspend => 330 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackBalloonChange => 331 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackPMsuspendDisk => 332 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventCallbackDeviceRemoved => 333 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainCoreDumpWithFormat => 334 */
remoteDispatchDomainCoreDumpWithFormatHelper,
sizeof(remote_domain_core_dump_with_format_args),
(xdrproc_t)xdr_remote_domain_core_dump_with_format_args,
0,
(xdrproc_t)xdr_void,
true,
0
},
};
size_t remoteNProcs = ARRAY_CARDINALITY(remoteProcs);
| Java |
<?php
namespace Bookly\Backend;
use Bookly\Backend\Modules;
use Bookly\Frontend;
use Bookly\Lib;
/**
* Class Backend
* @package Bookly\Backend
*/
class Backend
{
public function __construct()
{
// Backend controllers.
$this->apearanceController = Modules\Appearance\Controller::getInstance();
$this->calendarController = Modules\Calendar\Controller::getInstance();
$this->customerController = Modules\Customers\Controller::getInstance();
$this->notificationsController = Modules\Notifications\Controller::getInstance();
$this->paymentController = Modules\Payments\Controller::getInstance();
$this->serviceController = Modules\Services\Controller::getInstance();
$this->smsController = Modules\Sms\Controller::getInstance();
$this->settingsController = Modules\Settings\Controller::getInstance();
$this->staffController = Modules\Staff\Controller::getInstance();
$this->couponsController = Modules\Coupons\Controller::getInstance();
$this->customFieldsController = Modules\CustomFields\Controller::getInstance();
$this->appointmentsController = Modules\Appointments\Controller::getInstance();
$this->debugController = Modules\Debug\Controller::getInstance();
// Frontend controllers that work via admin-ajax.php.
$this->bookingController = Frontend\Modules\Booking\Controller::getInstance();
$this->customerProfileController = Frontend\Modules\CustomerProfile\Controller::getInstance();
if ( ! Lib\Config::isPaymentDisabled( Lib\Entities\Payment::TYPE_AUTHORIZENET ) ) {
$this->authorizeNetController = Frontend\Modules\AuthorizeNet\Controller::getInstance();
}
if ( ! Lib\Config::isPaymentDisabled( Lib\Entities\Payment::TYPE_PAYULATAM ) ) {
$this->payulatamController = Frontend\Modules\PayuLatam\Controller::getInstance();
}
if ( ! Lib\Config::isPaymentDisabled( Lib\Entities\Payment::TYPE_STRIPE ) ) {
$this->stripeController = Frontend\Modules\Stripe\Controller::getInstance();
}
$this->wooCommerceController = Frontend\Modules\WooCommerce\Controller::getInstance();
add_action( 'admin_menu', array( $this, 'addAdminMenu' ) );
add_action( 'wp_loaded', array( $this, 'init' ) );
add_action( 'admin_init', array( $this, 'addTinyMCEPlugin' ) );
}
public function init()
{
if ( ! session_id() ) {
@session_start();
}
}
public function addTinyMCEPlugin()
{
new Modules\TinyMce\Plugin();
}
public function addAdminMenu()
{
/** @var \WP_User $current_user */
global $current_user;
// Translated submenu pages.
$calendar = __( 'Calendar', 'bookly' );
$appointments = __( 'Appointments', 'bookly' );
$staff_members = __( 'Staff Members', 'bookly' );
$services = __( 'Services', 'bookly' );
$sms = __( 'SMS Notifications', 'bookly' );
$notifications = __( 'Email Notifications', 'bookly' );
$customers = __( 'Customers', 'bookly' );
$payments = __( 'Payments', 'bookly' );
$appearance = __( 'Appearance', 'bookly' );
$settings = __( 'Settings', 'bookly' );
$coupons = __( 'Coupons', 'bookly' );
$custom_fields = __( 'Custom Fields', 'bookly' );
if ( $current_user->has_cap( 'administrator' ) || Lib\Entities\Staff::query()->where( 'wp_user_id', $current_user->ID )->count() ) {
if ( function_exists( 'add_options_page' ) ) {
$dynamic_position = '80.0000001' . mt_rand( 1, 1000 ); // position always is under `Settings`
add_menu_page( 'Bookly', 'Bookly', 'read', 'ab-system', '',
plugins_url( 'resources/images/menu.png', __FILE__ ), $dynamic_position );
add_submenu_page( 'ab-system', $calendar, $calendar, 'read', 'ab-calendar',
array( $this->calendarController, 'index' ) );
add_submenu_page( 'ab-system', $appointments, $appointments, 'manage_options', 'ab-appointments',
array( $this->appointmentsController, 'index' ) );
do_action( 'bookly_render_menu_after_appointments' );
if ( $current_user->has_cap( 'administrator' ) ) {
add_submenu_page( 'ab-system', $staff_members, $staff_members, 'manage_options', Modules\Staff\Controller::page_slug,
array( $this->staffController, 'index' ) );
} else {
if ( get_option( 'ab_settings_allow_staff_members_edit_profile' ) == 1 ) {
add_submenu_page( 'ab-system', __( 'Profile', 'bookly' ), __( 'Profile', 'bookly' ), 'read', Modules\Staff\Controller::page_slug,
array( $this->staffController, 'index' ) );
}
}
add_submenu_page( 'ab-system', $services, $services, 'manage_options', Modules\Services\Controller::page_slug,
array( $this->serviceController, 'index' ) );
add_submenu_page( 'ab-system', $customers, $customers, 'manage_options', Modules\Customers\Controller::page_slug,
array( $this->customerController, 'index' ) );
add_submenu_page( 'ab-system', $notifications, $notifications, 'manage_options', 'ab-notifications',
array( $this->notificationsController, 'index' ) );
add_submenu_page( 'ab-system', $sms, $sms, 'manage_options', Modules\Sms\Controller::page_slug,
array( $this->smsController, 'index' ) );
add_submenu_page( 'ab-system', $payments, $payments, 'manage_options', 'ab-payments',
array( $this->paymentController, 'index' ) );
add_submenu_page( 'ab-system', $appearance, $appearance, 'manage_options', 'ab-appearance',
array( $this->apearanceController, 'index' ) );
add_submenu_page( 'ab-system', $custom_fields, $custom_fields, 'manage_options', 'ab-custom-fields',
array( $this->customFieldsController, 'index' ) );
add_submenu_page( 'ab-system', $coupons, $coupons, 'manage_options', 'ab-coupons',
array( $this->couponsController, 'index' ) );
add_submenu_page( 'ab-system', $settings, $settings, 'manage_options', Modules\Settings\Controller::page_slug,
array( $this->settingsController, 'index' ) );
if ( isset ( $_GET['page'] ) && $_GET['page'] == 'ab-debug' ) {
add_submenu_page( 'ab-system', 'Debug', 'Debug', 'manage_options', 'ab-debug',
array( $this->debugController, 'index' ) );
}
global $submenu;
do_action( 'bookly_admin_menu', 'ab-system' );
unset ( $submenu['ab-system'][0] );
}
}
}
} | Java |
## See "d_bankfull" in update_flow_depth() ######## (2/21/13)
## See "(5/13/10)" for a temporary fix.
#------------------------------------------------------------------------
# Copyright (c) 2001-2014, Scott D. Peckham
#
# Sep 2014. Wrote new update_diversions().
# New standard names and BMI updates and testing.
# Nov 2013. Converted TopoFlow to a Python package.
# Feb 2013. Adapted to use EMELI framework.
# Jan 2013. Shared scalar doubles are now 0D numpy arrays.
# This makes them mutable and allows components with
# a reference to them to see them change.
# So far: Q_outlet, Q_peak, Q_min...
# Jan 2013. Revised handling of input/output names.
# Oct 2012. CSDMS Standard Names and BMI.
# May 2012. Commented out diversions.update() for now. #######
# May 2012. Shared scalar doubles are now 1-element 1D numpy arrays.
# This makes them mutable and allows components with
# a reference to them to see them change.
# So far: Q_outlet, Q_peak, Q_min...
# May 2010. Changes to initialize() and read_cfg_file()
# Mar 2010. Changed codes to code, widths to width,
# angles to angle, nvals to nval, z0vals to z0val,
# slopes to slope (for GUI tools and consistency
# across all process components)
# Aug 2009. Updates.
# Jul 2009. Updates.
# May 2009. Updates.
# Jan 2009. Converted from IDL.
#-----------------------------------------------------------------------
# NB! In the CFG file, change MANNING and LAW_OF_WALL flags to
# a single string entry like "friction method". #########
#-----------------------------------------------------------------------
# Notes: Set self.u in manning and law_of_wall functions ??
# Update friction factor in manning() and law_of_wall() ?
# Double check how Rh is used in law_of_the_wall().
# d8_flow has "flow_grids", but this one has "codes".
# Make sure values are not stored twice.
#-----------------------------------------------------------------------
#-----------------------------------------------------------------------
# NOTES: This file defines a "base class" for channelized flow
# components as well as functions used by most or
# all channel flow methods. The methods of this class
# (especially "update_velocity") should be over-ridden as
# necessary for different methods of modeling channelized
# flow. See channels_kinematic_wave.py,
# channels_diffusive_wave.py and channels_dynamic_wave.py.
#-----------------------------------------------------------------------
# NOTES: update_free_surface_slope() is called by the
# update_velocity() methods of channels_diffusive_wave.py
# and channels_dynamic_wave.py.
#-----------------------------------------------------------------------
#
# class channels_component
#
# ## get_attribute() # (defined in each channel component)
# get_input_var_names() # (5/15/12)
# get_output_var_names() # (5/15/12)
# get_var_name() # (5/15/12)
# get_var_units() # (5/15/12)
#-----------------------------
# set_constants()
# initialize()
# update()
# finalize()
# set_computed_input_vars() # (5/11/10)
#----------------------------------
# initialize_d8_vars() ########
# initialize_computed_vars()
# initialize_diversion_vars() # (9/22/14)
# initialize_outlet_values()
# initialize_peak_values()
# initialize_min_and_max_values() # (2/3/13)
#-------------------------------------
# update_R()
# update_R_integral()
# update_discharge()
# update_diversions() # (9/22/14)
# update_flow_volume()
# update_flow_depth()
# update_free_surface_slope()
# update_shear_stress() # (9/9/14, depth-slope product)
# update_shear_speed() # (9/9/14)
# update_trapezoid_Rh()
# update_friction_factor() # (9/9/14)
#----------------------------------
# update_velocity() # (override as needed)
# update_velocity_on_edges()
# update_froude_number() # (9/9/14)
#----------------------------------
# update_outlet_values()
# update_peak_values() # (at the main outlet)
# update_Q_out_integral() # (moved here from basins.py)
# update_mins_and_maxes() # (don't add into update())
# check_flow_depth()
# check_flow_velocity()
#----------------------------------
# open_input_files()
# read_input_files()
# close_input_files()
#----------------------------------
# update_outfile_names()
# bundle_output_files() # (9/21/14. Not used yet)
# open_output_files()
# write_output_files()
# close_output_files()
# save_grids()
# save_pixel_values()
#----------------------------------
# manning_formula()
# law_of_the_wall()
# print_status_report()
# remove_bad_slopes()
# Functions: # (stand-alone versions of these)
# Trapezoid_Rh()
# Manning_Formula()
# Law_of_the_Wall()
#-----------------------------------------------------------------------
import numpy as np
import os, os.path
from topoflow.utils import BMI_base
# from topoflow.utils import d8_base
from topoflow.utils import file_utils ###
from topoflow.utils import model_input
from topoflow.utils import model_output
from topoflow.utils import ncgs_files ###
from topoflow.utils import ncts_files ###
from topoflow.utils import rtg_files ###
from topoflow.utils import text_ts_files ###
from topoflow.utils import tf_d8_base as d8_base
from topoflow.utils import tf_utils
#-----------------------------------------------------------------------
class channels_component( BMI_base.BMI_component ):
#-----------------------------------------------------------
# Note: rainfall_volume_flux *must* be liquid-only precip.
#-----------------------------------------------------------
_input_var_names = [
'atmosphere_water__rainfall_volume_flux', # (P_rain)
'glacier_ice__melt_volume_flux', # (MR)
## 'land_surface__elevation',
## 'land_surface__slope',
'land_surface_water__baseflow_volume_flux', # (GW)
'land_surface_water__evaporation_volume_flux', # (ET)
'soil_surface_water__infiltration_volume_flux', # (IN)
'snowpack__melt_volume_flux', # (SM)
'water-liquid__mass-per-volume_density' ] # (rho_H2O)
#------------------------------------------------------------------
# 'canals__count', # n_canals
# 'canals_entrance__x_coordinate', # canals_in_x
# 'canals_entrance__y_coordinate', # canals_in_y
# 'canals_entrance_water__volume_fraction', # Q_canals_fraction
# 'canals_exit__x_coordinate', # canals_out_x
# 'canals_exit__y_coordinate', # canals_out_y
# 'canals_exit_water__volume_flow_rate', # Q_canals_out
# 'sinks__count', # n_sinks
# 'sinks__x_coordinate', # sinks_x
# 'sinks__y_coordinate', # sinks_y
# 'sinks_water__volume_flow_rate', # Q_sinks
# 'sources__count', # n_sources
# 'sources__x_coordinate', # sources_x
# 'sources__y_coordinate', # sources_y
# 'sources_water__volume_flow_rate' ] # Q_sources
#----------------------------------
# Maybe add these out_vars later.
#----------------------------------
# ['time_sec', 'time_min' ]
_output_var_names = [
'basin_outlet_water_flow__half_of_fanning_friction_factor', # f_outlet
'basin_outlet_water_x-section__mean_depth', # d_outlet
'basin_outlet_water_x-section__peak_time_of_depth', # Td_peak
'basin_outlet_water_x-section__peak_time_of_volume_flow_rate', # T_peak
'basin_outlet_water_x-section__peak_time_of_volume_flux', # Tu_peak
'basin_outlet_water_x-section__time_integral_of_volume_flow_rate', # vol_Q
'basin_outlet_water_x-section__time_max_of_mean_depth', # d_peak
'basin_outlet_water_x-section__time_max_of_volume_flow_rate', # Q_peak
'basin_outlet_water_x-section__time_max_of_volume_flux', # u_peak
'basin_outlet_water_x-section__volume_flow_rate', # Q_outlet
'basin_outlet_water_x-section__volume_flux', # u_outlet
#--------------------------------------------------
'canals_entrance_water__volume_flow_rate', # Q_canals_in
#--------------------------------------------------
'channel_bottom_surface__slope', # S_bed
'channel_bottom_water_flow__domain_max_of_log_law_roughness_length', # z0val_max
'channel_bottom_water_flow__domain_min_of_log_law_roughness_length', # z0val_min
'channel_bottom_water_flow__log_law_roughness_length', # z0val
'channel_bottom_water_flow__magnitude_of_shear_stress', # tau
'channel_bottom_water_flow__shear_speed', # u_star
'channel_centerline__sinuosity', # sinu
'channel_water__volume', # vol
'channel_water_flow__froude_number', # froude
'channel_water_flow__half_of_fanning_friction_factor', # f
'channel_water_flow__domain_max_of_manning_n_parameter', # nval_max
'channel_water_flow__domain_min_of_manning_n_parameter', # nval_min
'channel_water_flow__manning_n_parameter', # nval
'channel_water_surface__slope', # S_free
#---------------------------------------------------
# These might only be available at the end of run.
#---------------------------------------------------
'channel_water_x-section__domain_max_of_mean_depth', # d_max
'channel_water_x-section__domain_min_of_mean_depth', # d_min
'channel_water_x-section__domain_max_of_volume_flow_rate', # Q_max
'channel_water_x-section__domain_min_of_volume_flow_rate', # Q_min
'channel_water_x-section__domain_max_of_volume_flux', # u_max
'channel_water_x-section__domain_min_of_volume_flux', # u_min
#---------------------------------------------------------------------
'channel_water_x-section__hydraulic_radius', # Rh
'channel_water_x-section__initial_mean_depth', # d0
'channel_water_x-section__mean_depth', # d
'channel_water_x-section__volume_flow_rate', # Q
'channel_water_x-section__volume_flux', # u
'channel_water_x-section__wetted_area', # A_wet
'channel_water_x-section__wetted_perimeter', # P_wet
## 'channel_water_x-section_top__width', # (not used)
'channel_x-section_trapezoid_bottom__width', # width
'channel_x-section_trapezoid_side__flare_angle', # angle
'land_surface_water__runoff_volume_flux', # R
'land_surface_water__domain_time_integral_of_runoff_volume_flux', # vol_R
'model__time_step', # dt
'model_grid_cell__area' ] # da
_var_name_map = {
'atmosphere_water__rainfall_volume_flux': 'P_rain',
'glacier_ice__melt_volume_flux': 'MR',
## 'land_surface__elevation': 'DEM',
## 'land_surface__slope': 'S_bed',
'land_surface_water__baseflow_volume_flux': 'GW',
'land_surface_water__evaporation_volume_flux': 'ET',
'soil_surface_water__infiltration_volume_flux': 'IN',
'snowpack__melt_volume_flux': 'SM',
'water-liquid__mass-per-volume_density': 'rho_H2O',
#------------------------------------------------------------------------
'basin_outlet_water_flow__half_of_fanning_friction_factor':'f_outlet',
'basin_outlet_water_x-section__mean_depth': 'd_outlet',
'basin_outlet_water_x-section__peak_time_of_depth': 'Td_peak',
'basin_outlet_water_x-section__peak_time_of_volume_flow_rate': 'T_peak',
'basin_outlet_water_x-section__peak_time_of_volume_flux': 'Tu_peak',
'basin_outlet_water_x-section__volume_flow_rate': 'Q_outlet',
'basin_outlet_water_x-section__volume_flux': 'u_outlet',
'basin_outlet_water_x-section__time_integral_of_volume_flow_rate': 'vol_Q',
'basin_outlet_water_x-section__time_max_of_mean_depth': 'd_peak',
'basin_outlet_water_x-section__time_max_of_volume_flow_rate':'Q_peak',
'basin_outlet_water_x-section__time_max_of_volume_flux': 'u_peak',
#--------------------------------------------------------------------------
'canals_entrance_water__volume_flow_rate': 'Q_canals_in',
#--------------------------------------------------------------------------
'channel_bottom_surface__slope': 'S_bed',
'channel_bottom_water_flow__domain_max_of_log_law_roughness_length': 'z0val_max',
'channel_bottom_water_flow__domain_min_of_log_law_roughness_length': 'z0val_min',
'channel_bottom_water_flow__log_law_roughness_length': 'z0val',
'channel_bottom_water_flow__magnitude_of_shear_stress': 'tau',
'channel_bottom_water_flow__shear_speed': 'u_star',
'channel_centerline__sinuosity': 'sinu',
'channel_water__volume': 'vol',
'channel_water_flow__domain_max_of_manning_n_parameter': 'nval_max',
'channel_water_flow__domain_min_of_manning_n_parameter': 'nval_min',
'channel_water_flow__froude_number': 'froude',
'channel_water_flow__half_of_fanning_friction_factor': 'f',
'channel_water_flow__manning_n_parameter': 'nval',
'channel_water_surface__slope': 'S_free',
#-----------------------------------------------------------------------
'channel_water_x-section__domain_max_of_mean_depth': 'd_max',
'channel_water_x-section__domain_min_of_mean_depth': 'd_min',
'channel_water_x-section__domain_max_of_volume_flow_rate': 'Q_max',
'channel_water_x-section__domain_min_of_volume_flow_rate': 'Q_min',
'channel_water_x-section__domain_max_of_volume_flux': 'u_max',
'channel_water_x-section__domain_min_of_volume_flux': 'u_min',
#-----------------------------------------------------------------------
'channel_water_x-section__hydraulic_radius': 'Rh',
'channel_water_x-section__initial_mean_depth': 'd0',
'channel_water_x-section__mean_depth': 'd',
'channel_water_x-section__volume_flow_rate': 'Q',
'channel_water_x-section__volume_flux': 'u',
'channel_water_x-section__wetted_area': 'A_wet',
'channel_water_x-section__wetted_perimeter': 'P_wet',
## 'channel_water_x-section_top__width': # (not used)
'channel_x-section_trapezoid_bottom__width': 'width', ####
'channel_x-section_trapezoid_side__flare_angle': 'angle', ####
'land_surface_water__domain_time_integral_of_runoff_volume_flux': 'vol_R',
'land_surface_water__runoff_volume_flux': 'R',
'model__time_step': 'dt',
'model_grid_cell__area': 'da',
#------------------------------------------------------------------
'canals__count': 'n_canals',
'canals_entrance__x_coordinate': 'canals_in_x',
'canals_entrance__y_coordinate': 'canals_in_y',
'canals_entrance_water__volume_fraction': 'Q_canals_fraction',
'canals_exit__x_coordinate': 'canals_out_x',
'canals_exit__y_coordinate': 'canals_out_y',
'canals_exit_water__volume_flow_rate': 'Q_canals_out',
'sinks__count': 'n_sinks',
'sinks__x_coordinate': 'sinks_x',
'sinks__y_coordinate': 'sinks_y',
'sinks_water__volume_flow_rate': 'Q_sinks',
'sources__count': 'n_sources',
'sources__x_coordinate': 'sources_x',
'sources__y_coordinate': 'sources_y',
'sources_water__volume_flow_rate': 'Q_sources' }
#------------------------------------------------
# Create an "inverse var name map"
# inv_map = dict(zip(map.values(), map.keys()))
#------------------------------------------------
## _long_name_map = dict( zip(_var_name_map.values(),
## _var_name_map.keys() ) )
_var_units_map = {
'atmosphere_water__rainfall_volume_flux': 'm s-1',
'glacier_ice__melt_volume_flux': 'm s-1',
## 'land_surface__elevation': 'm',
## 'land_surface__slope': '1',
'land_surface_water__baseflow_volume_flux': 'm s-1',
'land_surface_water__evaporation_volume_flux': 'm s-1',
'soil_surface_water__infiltration_volume_flux': 'm s-1',
'snowpack__melt_volume_flux': 'm s-1',
'water-liquid__mass-per-volume_density': 'kg m-3',
#---------------------------------------------------------------------------
'basin_outlet_water_flow__half_of_fanning_friction_factor': '1',
'basin_outlet_water_x-section__mean_depth': 'm',
'basin_outlet_water_x-section__peak_time_of_depth': 'min',
'basin_outlet_water_x-section__peak_time_of_volume_flow_rate': 'min',
'basin_outlet_water_x-section__peak_time_of_volume_flux': 'min',
'basin_outlet_water_x-section__time_integral_of_volume_flow_rate': 'm3',
'basin_outlet_water_x-section__time_max_of_mean_depth': 'm',
'basin_outlet_water_x-section__time_max_of_volume_flow_rate': 'm3 s-1',
'basin_outlet_water_x-section__time_max_of_volume_flux': 'm s-1',
'basin_outlet_water_x-section__volume_flow_rate': 'm3',
'basin_outlet_water_x-section__volume_flux': 'm s-1',
#---------------------------------------------------------------------------
'canals_entrance_water__volume_flow_rate': 'm3 s-1',
#---------------------------------------------------------------------------
'channel_bottom_surface__slope': '1',
'channel_bottom_water_flow__domain_max_of_log_law_roughness_length': 'm',
'channel_bottom_water_flow__domain_min_of_log_law_roughness_length': 'm',
'channel_bottom_water_flow__log_law_roughness_length': 'm',
'channel_bottom_water_flow__magnitude_of_shear_stress': 'kg m-1 s-2',
'channel_bottom_water_flow__shear_speed': 'm s-1',
'channel_centerline__sinuosity': '1',
'channel_water__volume': 'm3',
'channel_water_flow__froude_number': '1',
'channel_water_flow__half_of_fanning_friction_factor': '1',
'channel_water_flow__manning_n_parameter': 'm-1/3 s',
'channel_water_flow__domain_max_of_manning_n_parameter': 'm-1/3 s',
'channel_water_flow__domain_min_of_manning_n_parameter': 'm-1/3 s',
'channel_water_surface__slope': '1',
#--------------------------------------------------------------------
'channel_water_x-section__domain_max_of_mean_depth': 'm',
'channel_water_x-section__domain_min_of_mean_depth': 'm',
'channel_water_x-section__domain_max_of_volume_flow_rate': 'm3 s-1',
'channel_water_x-section__domain_min_of_volume_flow_rate': 'm3 s-1',
'channel_water_x-section__domain_max_of_volume_flux': 'm s-1',
'channel_water_x-section__domain_min_of_volume_flux': 'm s-1',
#--------------------------------------------------------------------
'channel_water_x-section__hydraulic_radius': 'm',
'channel_water_x-section__initial_mean_depth': 'm',
'channel_water_x-section__mean_depth': 'm',
'channel_water_x-section__volume_flow_rate': 'm3 s-1',
'channel_water_x-section__volume_flux': 'm s-1',
'channel_water_x-section__wetted_area': 'm2',
'channel_water_x-section__wetted_perimeter': 'm',
'channel_x-section_trapezoid_bottom__width': 'm',
'channel_x-section_trapezoid_side__flare_angle': 'rad', # CHECKED
'land_surface_water__domain_time_integral_of_runoff_volume_flux': 'm3',
'land_surface_water__runoff_volume_flux': 'm s-1',
'model__time_step': 's',
'model_grid_cell__area': 'm2',
#------------------------------------------------------------------
'canals__count': '1',
'canals_entrance__x_coordinate': 'm',
'canals_entrance__y_coordinate': 'm',
'canals_entrance_water__volume_fraction': '1',
'canals_exit__x_coordinate': 'm',
'canals_exit__y_coordinate': 'm',
'canals_exit_water__volume_flow_rate': 'm3 s-1',
'sinks__count': '1',
'sinks__x_coordinate': 'm',
'sinks__y_coordinate': 'm',
'sinks_water__volume_flow_rate': 'm3 s-1',
'sources__count': '1',
'sources__x_coordinate': 'm',
'sources__y_coordinate': 'm',
'sources_water__volume_flow_rate': 'm3 s-1' }
#------------------------------------------------
# Return NumPy string arrays vs. Python lists ?
#------------------------------------------------
## _input_var_names = np.array( _input_var_names )
## _output_var_names = np.array( _output_var_names )
#-------------------------------------------------------------------
def get_input_var_names(self):
#--------------------------------------------------------
# Note: These are currently variables needed from other
# components vs. those read from files or GUI.
#--------------------------------------------------------
return self._input_var_names
# get_input_var_names()
#-------------------------------------------------------------------
def get_output_var_names(self):
return self._output_var_names
# get_output_var_names()
#-------------------------------------------------------------------
def get_var_name(self, long_var_name):
return self._var_name_map[ long_var_name ]
# get_var_name()
#-------------------------------------------------------------------
def get_var_units(self, long_var_name):
return self._var_units_map[ long_var_name ]
# get_var_units()
#-------------------------------------------------------------------
## def get_var_type(self, long_var_name):
##
## #---------------------------------------
## # So far, all vars have type "double",
## # but use the one in BMI_base instead.
## #---------------------------------------
## return 'float64'
##
## # get_var_type()
#-------------------------------------------------------------------
def set_constants(self):
#------------------------
# Define some constants
#------------------------
self.g = np.float64(9.81) # (gravitation const.)
self.aval = np.float64(0.476) # (integration const.)
self.kappa = np.float64(0.408) # (von Karman's const.)
self.law_const = np.sqrt(self.g) / self.kappa
self.one_third = np.float64(1.0) / 3.0
self.two_thirds = np.float64(2.0) / 3.0
self.deg_to_rad = np.pi / 180.0
# set_constants()
#-------------------------------------------------------------------
def initialize(self, cfg_file=None, mode="nondriver", SILENT=False):
if not(SILENT):
print ' '
print 'Channels component: Initializing...'
self.status = 'initializing' # (OpenMI 2.0 convention)
self.mode = mode
self.cfg_file = cfg_file
#-----------------------------------------------
# Load component parameters from a config file
#-----------------------------------------------
self.set_constants() # (12/7/09)
# print 'CHANNELS calling initialize_config_vars()...'
self.initialize_config_vars()
# print 'CHANNELS calling read_grid_info()...'
self.read_grid_info()
#print 'CHANNELS calling initialize_basin_vars()...'
self.initialize_basin_vars() # (5/14/10)
#-----------------------------------------
# This must come before "Disabled" test.
#-----------------------------------------
# print 'CHANNELS calling initialize_time_vars()...'
self.initialize_time_vars()
#----------------------------------
# Has component been turned off ?
#----------------------------------
if (self.comp_status == 'Disabled'):
if not(SILENT):
print 'Channels component: Disabled.'
self.SAVE_Q_GRIDS = False # (It is True by default.)
self.SAVE_Q_PIXELS = False # (It is True by default.)
self.DONE = True
self.status = 'initialized' # (OpenMI 2.0 convention)
return
## print '################################################'
## print 'min(d0), max(d0) =', self.d0.min(), self.d0.max()
## print '################################################'
#---------------------------------------------
# Open input files needed to initialize vars
#---------------------------------------------
# Can't move read_input_files() to start of
# update(), since initial values needed here.
#---------------------------------------------
# print 'CHANNELS calling open_input_files()...'
self.open_input_files()
print 'CHANNELS calling read_input_files()...'
self.read_input_files()
#-----------------------
# Initialize variables
#-----------------------
print 'CHANNELS calling initialize_d8_vars()...'
self.initialize_d8_vars() # (depend on D8 flow grid)
print 'CHANNELS calling initialize_computed_vars()...'
self.initialize_computed_vars()
#--------------------------------------------------
# (5/12/10) I think this is obsolete now.
#--------------------------------------------------
# Make sure self.Q_ts_file is not NULL (12/22/05)
# This is only output file that is set by default
# and is still NULL if user hasn't opened the
# output var dialog for the channel process.
#--------------------------------------------------
## if (self.SAVE_Q_PIXELS and (self.Q_ts_file == '')):
## self.Q_ts_file = (self.case_prefix + '_0D-Q.txt')
self.open_output_files()
self.status = 'initialized' # (OpenMI 2.0 convention)
# initialize()
#-------------------------------------------------------------------
## def update(self, dt=-1.0, time_seconds=None):
def update(self, dt=-1.0):
#---------------------------------------------
# Note that u and d from previous time step
# must be used on RHS of the equations here.
#---------------------------------------------
self.status = 'updating' # (OpenMI 2.0 convention)
#-------------------------------------------------------
# There may be times where we want to call this method
# even if component is not the driver. But note that
# the TopoFlow driver also makes this same call.
#-------------------------------------------------------
if (self.mode == 'driver'):
self.print_time_and_value(self.Q_outlet, 'Q_out', '[m^3/s]')
### interval=0.5) # [seconds]
# For testing (5/19/12)
# self.print_time_and_value(self.Q_outlet, 'Q_out', '[m^3/s] CHANNEL')
## DEBUG = True
DEBUG = False
#-------------------------
# Update computed values
#-------------------------
if (DEBUG): print '#### Calling update_R()...'
self.update_R()
if (DEBUG): print '#### Calling update_R_integral()...'
self.update_R_integral()
if (DEBUG): print '#### Calling update_discharge()...'
self.update_discharge()
if (DEBUG): print '#### Calling update_diversions()...'
self.update_diversions()
if (DEBUG): print '#### Calling update_flow_volume()...'
self.update_flow_volume()
if (DEBUG): print '#### Calling update_flow_depth()...'
self.update_flow_depth()
#-----------------------------------------------------------------
if not(self.DYNAMIC_WAVE):
if (DEBUG): print '#### Calling update_trapezoid_Rh()...'
self.update_trapezoid_Rh()
# print 'Rhmin, Rhmax =', self.Rh.min(), self.Rh.max()a
#-----------------------------------------------------------------
# (9/9/14) Moved this here from update_velocity() methods.
#-----------------------------------------------------------------
if not(self.KINEMATIC_WAVE):
if (DEBUG): print '#### Calling update_free_surface_slope()...'
self.update_free_surface_slope()
if (DEBUG): print '#### Calling update_shear_stress()...'
self.update_shear_stress()
if (DEBUG): print '#### Calling update_shear_speed()...'
self.update_shear_speed()
#-----------------------------------------------------------------
# Must update friction factor before velocity for DYNAMIC_WAVE.
#-----------------------------------------------------------------
if (DEBUG): print '#### Calling update_friction_factor()...'
self.update_friction_factor()
#-----------------------------------------------------------------
if (DEBUG): print '#### Calling update_velocity()...'
self.update_velocity()
self.update_velocity_on_edges() # (set to zero)
if (DEBUG): print '#### Calling update_froude_number()...'
self.update_froude_number()
#-----------------------------------------------------------------
## print 'Rmin, Rmax =', self.R.min(), self.R.max()
## print 'Qmin, Qmax =', self.Q.min(), self.Q.max()
## print 'umin, umax =', self.u.min(), self.u.max()
## print 'dmin, dmax =', self.d.min(), self.d.max()
## print 'nmin, nmax =', self.nval.min(), self.nval.max()
## print 'Rhmin, Rhmax =', self.Rh.min(), self.Rh.max()
## print 'Smin, Smax =', self.S_bed.min(), self.S_bed.max()
if (DEBUG): print '#### Calling update_outlet_values()...'
self.update_outlet_values()
if (DEBUG): print '#### Calling update peak values()...'
self.update_peak_values()
if (DEBUG): print '#### Calling update_Q_out_integral()...'
self.update_Q_out_integral()
#---------------------------------------------
# This takes extra time and is now done
# only at the end, in finalize(). (8/19/13)
#---------------------------------------------
# But then "topoflow_driver" doesn't get
# correctly updated values for some reason.
#---------------------------------------------
## self.update_mins_and_maxes()
#------------------------
# Check computed values
#------------------------
D_OK = self.check_flow_depth()
U_OK = self.check_flow_velocity()
OK = (D_OK and U_OK)
#-------------------------------------------
# Read from files as needed to update vars
#-----------------------------------------------------
# NB! This is currently not needed for the "channel
# process" because values don't change over time and
# read_input_files() is called by initialize().
#-----------------------------------------------------
# if (self.time_index > 0):
# self.read_input_files()
#----------------------------------------------
# Write user-specified data to output files ?
#----------------------------------------------
# Components use own self.time_sec by default.
#-----------------------------------------------
if (DEBUG): print '#### Calling write_output_files()...'
self.write_output_files()
## self.write_output_files( time_seconds )
#-----------------------------
# Update internal clock
# after write_output_files()
#-----------------------------
if (DEBUG): print '#### Calling update_time()'
self.update_time( dt )
if (OK):
self.status = 'updated' # (OpenMI 2.0 convention)
else:
self.status = 'failed'
self.DONE = True
# update()
#-------------------------------------------------------------------
def finalize(self):
#---------------------------------------------------
# We can compute mins and maxes in the final grids
# here, but the framework will not then pass them
# to any component (e.g. topoflow_driver) that may
# need them.
#---------------------------------------------------
REPORT = True
self.update_mins_and_maxes( REPORT=REPORT ) ## (2/6/13)
self.print_final_report(comp_name='Channels component')
self.status = 'finalizing' # (OpenMI)
self.close_input_files() # TopoFlow input "data streams"
self.close_output_files()
self.status = 'finalized' # (OpenMI)
#---------------------------
# Release all of the ports
#----------------------------------------
# Make this call in "finalize()" method
# of the component's CCA Imple file
#----------------------------------------
# self.release_cca_ports( d_services )
# finalize()
#-------------------------------------------------------------------
def set_computed_input_vars(self):
#---------------------------------------------------------------
# Note: The initialize() method calls initialize_config_vars()
# (in BMI_base.py), which calls this method at the end.
#--------------------------------------------------------------
cfg_extension = self.get_attribute( 'cfg_extension' ).lower()
# cfg_extension = self.get_cfg_extension().lower()
self.KINEMATIC_WAVE = ("kinematic" in cfg_extension)
self.DIFFUSIVE_WAVE = ("diffusive" in cfg_extension)
self.DYNAMIC_WAVE = ("dynamic" in cfg_extension)
##########################################################
# (5/17/12) If MANNING, we need to set z0vals to -1 so
# they are always defined for use with new framework.
##########################################################
if (self.MANNING):
if (self.nval != None):
self.nval = np.float64( self.nval ) #### 10/9/10, NEED
self.nval_min = self.nval.min()
self.nval_max = self.nval.max()
#-----------------------------------
self.z0val = np.float64(-1)
self.z0val_min = np.float64(-1)
self.z0val_max = np.float64(-1)
if (self.LAW_OF_WALL):
if (self.z0val != None):
self.z0val = np.float64( self.z0val ) #### (10/9/10)
self.z0val_min = self.z0val.min()
self.z0val_max = self.z0val.max()
#-----------------------------------
self.nval = np.float64(-1)
self.nval_min = np.float64(-1)
self.nval_max = np.float64(-1)
#-------------------------------------------
# These currently can't be set to anything
# else in the GUI, but need to be defined.
#-------------------------------------------
self.code_type = 'Grid'
self.slope_type = 'Grid'
#---------------------------------------------------------
# Make sure that all "save_dts" are larger or equal to
# the specified process dt. There is no point in saving
# results more often than they change.
# Issue a message to this effect if any are smaller ??
#---------------------------------------------------------
self.save_grid_dt = np.maximum(self.save_grid_dt, self.dt)
self.save_pixels_dt = np.maximum(self.save_pixels_dt, self.dt)
#---------------------------------------------------
# This is now done in CSDMS_base.read_config_gui()
# for any var_name that starts with "SAVE_".
#---------------------------------------------------
# self.SAVE_Q_GRID = (self.SAVE_Q_GRID == 'Yes')
# set_computed_input_vars()
#-------------------------------------------------------------------
def initialize_d8_vars(self):
#---------------------------------------------
# Compute and store a variety of (static) D8
# flow grid variables. Embed structure into
# the "channel_base" component.
#---------------------------------------------
self.d8 = d8_base.d8_component()
###############################################
# (5/13/10) Do next line here for now, until
# the d8 cfg_file includes static prefix.
# Same is done in GW_base.py.
###############################################
# tf_d8_base.read_grid_info() also needs
# in_directory to be set. (10/27/11)
###############################################
#--------------------------------------------------
# D8 component builds its cfg filename from these
#--------------------------------------------------
self.d8.site_prefix = self.site_prefix
self.d8.in_directory = self.in_directory
self.d8.initialize( cfg_file=None,
SILENT=self.SILENT,
REPORT=self.REPORT )
## self.code = self.d8.code # Don't need this.
#-------------------------------------------
# We'll need this once we shift from using
# "tf_d8_base.py" to the new "d8_base.py"
#-------------------------------------------
# self.d8.update(self.time, SILENT=False, REPORT=True)
# initialize_d8_vars()
#-------------------------------------------------------------
def initialize_computed_vars(self):
#-----------------------------------------------
# Convert bank angles from degrees to radians.
#-----------------------------------------------
self.angle = self.angle * self.deg_to_rad # [radians]
#------------------------------------------------
# 8/29/05. Multiply ds by (unitless) sinuosity
# Orig. ds is used by subsurface flow
#------------------------------------------------
# NB! We should also divide slopes in S_bed by
# the sinuosity, as now done here.
#----------------------------------------------------
# NB! This saves a modified version of ds that
# is only used within the "channels" component.
# The original "ds" is stored within the
# topoflow model component and is used for
# subsurface flow, etc.
#----------------------------------------------------
### self.d8.ds_chan = (self.sinu * ds)
### self.ds = (self.sinu * self.d8.ds)
self.d8.ds = (self.sinu * self.d8.ds) ### USE LESS MEMORY
###################################################
###################################################
### S_bed = (S_bed / self.sinu) #*************
self.slope = (self.slope / self.sinu)
self.S_bed = self.slope
###################################################
###################################################
#---------------------------
# Initialize spatial grids
#-----------------------------------------------
# NB! It is not a good idea to initialize the
# water depth grid to a nonzero scalar value.
#-----------------------------------------------
print 'Initializing u, f, d grids...'
self.u = np.zeros([self.ny, self.nx], dtype='Float64')
self.f = np.zeros([self.ny, self.nx], dtype='Float64')
self.d = np.zeros([self.ny, self.nx], dtype='Float64') + self.d0
#########################################################
# Add this on (2/3/13) so make the TF driver happy
# during its initialize when it gets reference to R.
# But in "update_R()", be careful not to break the ref.
# "Q" may be subject to the same issue.
#########################################################
self.Q = np.zeros([self.ny, self.nx], dtype='Float64')
self.R = np.zeros([self.ny, self.nx], dtype='Float64')
#---------------------------------------------------
# Initialize new grids. Is this needed? (9/13/14)
#---------------------------------------------------
self.tau = np.zeros([self.ny, self.nx], dtype='Float64')
self.u_star = np.zeros([self.ny, self.nx], dtype='Float64')
self.froude = np.zeros([self.ny, self.nx], dtype='Float64')
#---------------------------------------
# These are used to check mass balance
#---------------------------------------
self.vol_R = self.initialize_scalar( 0, dtype='float64')
self.vol_Q = self.initialize_scalar( 0, dtype='float64')
#-------------------------------------------
# Make sure all slopes are valid & nonzero
# since otherwise flow will accumulate
#-------------------------------------------
if (self.KINEMATIC_WAVE):
self.remove_bad_slopes() #(3/8/07. Only Kin Wave case)
#----------------------------------------
# Initial volume of water in each pixel
#-----------------------------------------------------------
# Note: angles were read as degrees & converted to radians
#-----------------------------------------------------------
L2 = self.d * np.tan(self.angle)
self.A_wet = self.d * (self.width + L2)
self.P_wet = self.width + (np.float64(2) * self.d / np.cos(self.angle) )
self.vol = self.A_wet * self.d8.ds # [m3]
#-------------------------------------------------------
# Note: depth is often zero at the start of a run, and
# both width and then P_wet are also zero in places.
# Therefore initialize Rh as shown.
#-------------------------------------------------------
self.Rh = np.zeros([self.ny, self.nx], dtype='Float64')
## self.Rh = self.A_wet / self.P_wet # [m]
## print 'P_wet.min() =', self.P_wet.min()
## print 'width.min() =', self.width.min()
## self.initialize_diversion_vars() # (9/22/14)
self.initialize_outlet_values()
self.initialize_peak_values()
self.initialize_min_and_max_values() ## (2/3/13)
#########################################
# Maybe save all refs in a dictionary
# called "self_values" here ? (2/19/13)
# Use a "reverse" var_name mapping?
# inv_map = dict(zip(map.values(), map.keys()))
#########################################
## w = np.where( self.width <= 0 )
## nw = np.size( w[0] ) # (This is correct for 1D or 2D.)
## if (nw > 0):
## print 'WARNING:'
## print 'Number of locations where width==0 =', nw
## if (nw < 10):
## print 'locations =', w
## print ' '
# initialize_computed_vars()
#-------------------------------------------------------------
def initialize_diversion_vars(self):
#-----------------------------------------
# Compute source IDs from xy coordinates
#-----------------------------------------
source_rows = np.int32( self.sources_y / self.ny )
source_cols = np.int32( self.sources_x / self.nx )
self.source_IDs = (source_rows, source_cols)
## self.source_IDs = (source_rows * self.nx) + source_cols
#---------------------------------------
# Compute sink IDs from xy coordinates
#---------------------------------------
sink_rows = np.int32( self.sinks_y / self.ny )
sink_cols = np.int32( self.sinks_x / self.nx )
self.sink_IDs = (sink_rows, sink_cols)
## self.sink_IDs = (sink_rows * self.nx) + sink_cols
#-------------------------------------------------
# Compute canal entrance IDs from xy coordinates
#-------------------------------------------------
canal_in_rows = np.int32( self.canals_in_y / self.ny )
canal_in_cols = np.int32( self.canals_in_x / self.nx )
self.canal_in_IDs = (canal_in_rows, canal_in_cols)
## self.canal_in_IDs = (canal_in_rows * self.nx) + canal_in_cols
#---------------------------------------------
# Compute canal exit IDs from xy coordinates
#---------------------------------------------
canal_out_rows = np.int32( self.canals_out_y / self.ny )
canal_out_cols = np.int32( self.canals_out_x / self.nx )
self.canal_out_IDs = (canal_out_rows, canal_out_cols)
## self.canal_out_IDs = (canal_out_rows * self.nx) + canal_out_cols
#--------------------------------------------------
# This will be computed from Q_canal_fraction and
# self.Q and then passed back to Diversions
#--------------------------------------------------
self.Q_canals_in = np.array( self.n_sources, dtype='float64' )
# initialize_diversion_vars()
#-------------------------------------------------------------------
def initialize_outlet_values(self):
#---------------------------------------------------
# Note: These are retrieved and used by TopoFlow
# for the stopping condition. TopoFlow
# receives a reference to these, but in
# order to see the values change they need
# to be stored as mutable, 1D numpy arrays.
#---------------------------------------------------
# Note: Q_last is internal to TopoFlow.
#---------------------------------------------------
# self.Q_outlet = self.Q[ self.outlet_ID ]
self.Q_outlet = self.initialize_scalar(0, dtype='float64')
self.u_outlet = self.initialize_scalar(0, dtype='float64')
self.d_outlet = self.initialize_scalar(0, dtype='float64')
self.f_outlet = self.initialize_scalar(0, dtype='float64')
# initialize_outlet_values()
#-------------------------------------------------------------------
def initialize_peak_values(self):
#-------------------------
# Initialize peak values
#-------------------------
self.Q_peak = self.initialize_scalar(0, dtype='float64')
self.T_peak = self.initialize_scalar(0, dtype='float64')
self.u_peak = self.initialize_scalar(0, dtype='float64')
self.Tu_peak = self.initialize_scalar(0, dtype='float64')
self.d_peak = self.initialize_scalar(0, dtype='float64')
self.Td_peak = self.initialize_scalar(0, dtype='float64')
# initialize_peak_values()
#-------------------------------------------------------------------
def initialize_min_and_max_values(self):
#-------------------------------
# Initialize min & max values
# (2/3/13), for new framework.
#-------------------------------
v = 1e6
self.Q_min = self.initialize_scalar(v, dtype='float64')
self.Q_max = self.initialize_scalar(-v, dtype='float64')
self.u_min = self.initialize_scalar(v, dtype='float64')
self.u_max = self.initialize_scalar(-v, dtype='float64')
self.d_min = self.initialize_scalar(v, dtype='float64')
self.d_max = self.initialize_scalar(-v, dtype='float64')
# initialize_min_and_max_values()
#-------------------------------------------------------------------
# def update_excess_rainrate(self):
def update_R(self):
#----------------------------------------
# Compute the "excess rainrate", R.
# Each term must have same units: [m/s]
# Sum = net gain/loss rate over pixel.
#----------------------------------------------------
# R can be positive or negative. If negative, then
# water is removed from the surface at rate R until
# surface water is consumed.
#--------------------------------------------------------------
# P = precip_rate [m/s] (converted by read_input_data()).
# SM = snowmelt rate [m/s]
# GW = seep rate [m/s] (water_table intersects surface)
# ET = evap rate [m/s]
# IN = infil rate [m/s]
# MR = icemelt rate [m/s]
#------------------------------------------------------------
# Use refs to other comp vars from new framework. (5/18/12)
#------------------------------------------------------------
P = self.P_rain # (This is now liquid-only precip. 9/14/14)
SM = self.SM
GW = self.GW
ET = self.ET
IN = self.IN
MR = self.MR
## if (self.DEBUG):
## print 'At time:', self.time_min, ', P =', P, '[m/s]'
#--------------
# For testing
#--------------
## print '(Pmin, Pmax) =', P.min(), P.max()
## print '(SMmin, SMmax) =', SM.min(), SM.max()
## print '(GWmin, GWmax) =', GW.min(), GW.max()
## print '(ETmin, ETmax) =', ET.min(), ET.max()
## print '(INmin, INmax) =', IN.min(), IN.max()
## print '(MRmin, MRmax) =', MR.min(), MR.max()
## # print '(Hmin, Hmax) =', H.min(), H.max()
## print ' '
self.R = (P + SM + GW + MR) - (ET + IN)
# update_R()
#-------------------------------------------------------------------
def update_R_integral(self):
#-----------------------------------------------
# Update mass total for R, sum over all pixels
#-----------------------------------------------
volume = np.double(self.R * self.da * self.dt) # [m^3]
if (np.size(volume) == 1):
self.vol_R += (volume * self.rti.n_pixels)
else:
self.vol_R += np.sum(volume)
# update_R_integral()
#-------------------------------------------------------------------
def update_discharge(self):
#---------------------------------------------------------
# The discharge grid, Q, gives the flux of water _out_
# of each grid cell. This entire amount then flows
# into one of the 8 neighbor grid cells, as indicated
# by the D8 flow code. The update_flow_volume() function
# is called right after this one in update() and uses
# the Q grid.
#---------------------------------------------------------
# 7/15/05. The cross-sectional area of a trapezoid is
# given by: Ac = d * (w + (d * tan(theta))),
# where w is the bottom width. If we were to
# use: Ac = w * d, then we'd have Ac=0 when w=0.
# We also need angle units to be radians.
#---------------------------------------------------------
#-----------------------------
# Compute the discharge grid
#------------------------------------------------------
# A_wet is initialized in initialize_computed_vars().
# A_wet is updated in update_trapezoid_Rh().
#------------------------------------------------------
### self.Q = np.float64(self.u * A_wet)
self.Q[:] = self.u * self.A_wet ## (2/19/13, in place)
#--------------
# For testing
#--------------
## print '(umin, umax) =', self.u.min(), self.u.max()
## print '(d0min, d0max) =', self.d0.min(), self.d0.max()
## print '(dmin, dmax) =', self.d.min(), self.d.max()
## print '(amin, amax) =', self.angle.min(), self.angle.max()
## print '(wmin, wmax) =', self.width.min(), self.width.max()
## print '(Qmin, Qmax) =', self.Q.min(), self.Q.max()
## print '(L2min, L2max) =', L2.min(), L2.max()
## print '(Qmin, Qmax) =', self.Q.min(), self.Q.max()
#--------------
# For testing
#--------------
# print 'dmin, dmax =', self.d.min(), self.d.max()
# print 'umin, umax =', self.u.min(), self.u.max()
# print 'Qmin, Qmax =', self.Q.min(), self.Q.max()
# print ' '
# print 'u(outlet) =', self.u[self.outlet_ID]
# print 'Q(outlet) =', self.Q[self.outlet_ID] ########
#----------------------------------------------------
# Wherever depth is less than z0, assume that water
# is not flowing and set u and Q to zero.
# However, we also need (d gt 0) to avoid a divide
# by zero problem, even when numerators are zero.
#----------------------------------------------------
# FLOWING = (d > (z0/aval))
#*** FLOWING[self.d8.noflow_IDs] = False ;******
# u = (u * FLOWING)
# Q = (Q * FLOWING)
# d = np.maximum(d, 0.0) ;(allow depths lt z0, if gt 0.)
# update_discharge()
#-------------------------------------------------------------------
def update_diversions(self):
#--------------------------------------------------------------
# Note: The Channel component requests the following input
# vars from the Diversions component by including
# them in its "get_input_vars()":
# (1) Q_sources, Q_sources_x, Q_sources_y
# (2) Q_sinks, Q_sinks_x, Q_sinks_y
# (3) Q_canals_out, Q_canals_out_x, Q_canals_out_y
# (4) Q_canals_fraction, Q_canals_in_x, Q_canals_in_y.
# source_IDs are computed from (x,y) coordinates during
# initialize().
#
# Diversions component needs to get Q_canals_in from the
# Channel component.
#--------------------------------------------------------------
# Note: This *must* be called after update_discharge() and
# before update_flow_volume().
#--------------------------------------------------------------
# Note: The Q grid stores the volume flow rate *leaving* each
# grid cell in the domain. For sources, an extra amount
# is leaving the cell which can flow into its D8 parent
# cell. For sinks, a lesser amount is leaving the cell
# toward the D8 parent.
#--------------------------------------------------------------
# Note: It is not enough to just update Q and then call the
# update_flow_volume() method. This is because it
# won't update the volume in the channels in the grid
# cells that the extra discharge is leaving from.
#--------------------------------------------------------------
# If a grid cell contains a "source", then an additional Q
# will flow *into* that grid cell and increase flow volume.
#--------------------------------------------------------------
#-------------------------------------------------------------
# This is not fully tested but runs. However, the Diversion
# vars are still computed even when Diversions component is
# disabled. So it slows things down somewhat.
#-------------------------------------------------------------
return
########################
########################
#----------------------------------------
# Update Q and vol due to point sources
#----------------------------------------
## if (hasattr(self, 'source_IDs')):
if (self.n_sources > 0):
self.Q[ self.source_IDs ] += self.Q_sources
self.vol[ self.source_IDs ] += (self.Q_sources * self.dt)
#--------------------------------------
# Update Q and vol due to point sinks
#--------------------------------------
## if (hasattr(self, 'sink_IDs')):
if (self.n_sinks > 0):
self.Q[ self.sink_IDs ] -= self.Q_sinks
self.vol[ self.sink_IDs ] -= (self.Q_sinks * self.dt)
#---------------------------------------
# Update Q and vol due to point canals
#---------------------------------------
## if (hasattr(self, 'canal_in_IDs')):
if (self.n_canals > 0):
#-----------------------------------------------------------------
# Q grid was just modified. Apply the canal diversion fractions
# to compute the volume flow rate into upstream ends of canals.
#-----------------------------------------------------------------
Q_canals_in = self.Q_canals_fraction * self.Q[ self.canal_in_IDs ]
self.Q_canals_in = Q_canals_in
#----------------------------------------------------
# Update Q and vol due to losses at canal entrances
#----------------------------------------------------
self.Q[ self.canal_in_IDs ] -= Q_canals_in
self.vol[ self.canal_in_IDs ] -= (Q_canals_in * self.dt)
#-------------------------------------------------
# Update Q and vol due to gains at canal exits.
# Diversions component accounts for travel time.
#-------------------------------------------------
self.Q[ self.canal_out_IDs ] += self.Q_canals_out
self.vol[ self.canal_out_IDs ] += (self.Q_canals_out * self.dt)
# update_diversions()
#-------------------------------------------------------------------
def update_flow_volume(self):
#-----------------------------------------------------------
# Notes: This function must be called after
# update_discharge() and update_diversions().
#-----------------------------------------------------------
# Notes: Q = surface discharge [m^3/s]
# R = excess precip. rate [m/s]
# da = pixel area [m^2]
# dt = channel flow timestep [s]
# vol = total volume of water in pixel [m^3]
# v2 = temp version of vol
# w1 = IDs of pixels that...
# p1 = IDs of parent pixels that...
#-----------------------------------------------------------
dt = self.dt # [seconds]
#----------------------------------------------------
# Add contribution (or loss ?) from excess rainrate
#----------------------------------------------------
# Contributions over entire grid cell from rainfall,
# snowmelt, icemelt and baseflow (minus losses from
# evaporation and infiltration) are assumed to flow
# into the channel within the grid cell.
# Note that R is allowed to be negative.
#----------------------------------------------------
self.vol += (self.R * self.da) * dt # (in place)
#-----------------------------------------
# Add contributions from neighbor pixels
#-------------------------------------------------------------
# Each grid cell passes flow to *one* downstream neighbor.
# Note that multiple grid cells can flow toward a given grid
# cell, so a grid cell ID may occur in d8.p1 and d8.p2, etc.
#-------------------------------------------------------------
# (2/16/10) RETEST THIS. Before, a copy called "v2" was
# used but this doesn't seem to be necessary.
#-------------------------------------------------------------
if (self.d8.p1_OK):
self.vol[ self.d8.p1 ] += (dt * self.Q[self.d8.w1])
if (self.d8.p2_OK):
self.vol[ self.d8.p2 ] += (dt * self.Q[self.d8.w2])
if (self.d8.p3_OK):
self.vol[ self.d8.p3 ] += (dt * self.Q[self.d8.w3])
if (self.d8.p4_OK):
self.vol[ self.d8.p4 ] += (dt * self.Q[self.d8.w4])
if (self.d8.p5_OK):
self.vol[ self.d8.p5 ] += (dt * self.Q[self.d8.w5])
if (self.d8.p6_OK):
self.vol[ self.d8.p6 ] += (dt * self.Q[self.d8.w6])
if (self.d8.p7_OK):
self.vol[ self.d8.p7 ] += (dt * self.Q[self.d8.w7])
if (self.d8.p8_OK):
self.vol[ self.d8.p8 ] += (dt * self.Q[self.d8.w8])
#----------------------------------------------------
# Subtract the amount that flows out to D8 neighbor
#----------------------------------------------------
self.vol -= (self.Q * dt) # (in place)
#--------------------------------------------------------
# While R can be positive or negative, the surface flow
# volume must always be nonnegative. This also ensures
# that the flow depth is nonnegative. (7/13/06)
#--------------------------------------------------------
## self.vol = np.maximum(self.vol, 0.0)
## self.vol[:] = np.maximum(self.vol, 0.0) # (2/19/13)
np.maximum( self.vol, 0.0, self.vol ) # (in place)
# update_flow_volume
#-------------------------------------------------------------------
def update_flow_depth(self):
#-----------------------------------------------------------
# Notes: 7/18/05. Modified to use the equation for volume
# of a trapezoidal channel: vol = Ac * ds, where
# Ac=d*[w + d*tan(t)], and to solve the resulting
# quadratic (discarding neg. root) for new depth, d.
# 8/29/05. Now original ds is used for subsurface
# flow and there is a ds_chan which can include a
# sinuosity greater than 1. This may be especially
# important for larger pixel sizes.
# Removed (ds > 1) here which was only meant to
# avoid a "divide by zero" error at pixels where
# (ds eq 0). This isn't necessary since the
# Flow_Lengths function in utils_TF.pro never
# returns a value of zero.
#----------------------------------------------------------
# Modified to avoid double where calls, which
# reduced cProfile run time for this method from
# 1.391 to 0.644. (9/23/14)
#----------------------------------------------------------
# Commented this out on (2/18/10) because it doesn't
# seem to be used anywhere now. Checked all
# of the Channels components.
#----------------------------------------------------------
# self.d_last = self.d.copy()
#-----------------------------------
# Make some local aliases and vars
#-----------------------------------------------------------
# Note: angles were read as degrees & converted to radians
#-----------------------------------------------------------
d = self.d
width = self.width ###
angle = self.angle
SCALAR_ANGLES = (np.size(angle) == 1)
#------------------------------------------------------
# (2/18/10) New code to deal with case where the flow
# depth exceeds a bankfull depth.
# For now, d_bankfull is hard-coded.
#
# CHANGE Manning's n here, too?
#------------------------------------------------------
d_bankfull = 4.0 # [meters]
################################
wb = (self.d > d_bankfull) # (array of True or False)
self.width[ wb ] = self.d8.dw[ wb ]
if not(SCALAR_ANGLES):
self.angle[ wb ] = 0.0
# w_overbank = np.where( d > d_bankfull )
# n_overbank = np.size( w_overbank[0] )
# if (n_overbank != 0):
# width[ w_overbank ] = self.d8.dw[ w_overbank ]
# if not(SCALAR_ANGLES): angle[w_overbank] = 0.0
#------------------------------------------------------
# (2/18/10) New code to deal with case where the top
# width exceeds the grid cell width, dw.
#------------------------------------------------------
top_width = width + (2.0 * d * np.sin(self.angle))
wb = (top_width > self.d8.dw) # (array of True or False)
self.width[ wb ] = self.d8.dw[ wb ]
if not(SCALAR_ANGLES):
self.angle[ wb ] = 0.0
# wb = np.where(top_width > self.d8.dw)
# nb = np.size(w_bad[0])
# if (nb != 0):
# width[ wb ] = self.d8.dw[ wb ]
# if not(SCALAR_ANGLES): angle[ wb ] = 0.0
#----------------------------------
# Is "angle" a scalar or a grid ?
#----------------------------------
if (SCALAR_ANGLES):
if (angle == 0.0):
d = self.vol / (width * self.d8.ds)
else:
denom = 2.0 * np.tan(angle)
arg = 2.0 * denom * self.vol / self.d8.ds
arg += width**(2.0)
d = (np.sqrt(arg) - width) / denom
else:
#-----------------------------------------------------
# Pixels where angle is 0 must be handled separately
#-----------------------------------------------------
w1 = ( angle == 0 ) # (arrays of True or False)
w2 = np.invert( w1 )
#-----------------------------------
A_top = width[w1] * self.d8.ds[w1]
d[w1] = self.vol[w1] / A_top
#-----------------------------------
denom = 2.0 * np.tan(angle[w2])
arg = 2.0 * denom * self.vol[w2] / self.d8.ds[w2]
arg += width[w2]**(2.0)
d[w2] = (np.sqrt(arg) - width[w2]) / denom
#-----------------------------------------------------
# Pixels where angle is 0 must be handled separately
#-----------------------------------------------------
# wz = np.where( angle == 0 )
# nwz = np.size( wz[0] )
# wzc = np.where( angle != 0 )
# nwzc = np.size( wzc[0] )
#
# if (nwz != 0):
# A_top = width[wz] * self.d8.ds[wz]
# ## A_top = self.width[wz] * self.d8.ds_chan[wz]
# d[wz] = self.vol[wz] / A_top
#
# if (nwzc != 0):
# term1 = 2.0 * np.tan(angle[wzc])
# arg = 2.0 * term1 * self.vol[wzc] / self.d8.ds[wzc]
# arg += width[wzc]**(2.0)
# d[wzc] = (np.sqrt(arg) - width[wzc]) / term1
#------------------------------------------
# Set depth values on edges to zero since
# they become spikes (no outflow) 7/15/06
#------------------------------------------
d[ self.d8.noflow_IDs ] = 0.0
#------------------------------------------------
# 4/19/06. Force flow depth to be positive ?
#------------------------------------------------
# This seems to be needed with the non-Richards
# infiltration routines when starting with zero
# depth everywhere, since all water infiltrates
# for some period of time. It also seems to be
# needed more for short rainfall records to
# avoid a negative flow depth error.
#------------------------------------------------
# 7/13/06. Still needed for Richards method
#------------------------------------------------
## self.d = np.maximum(d, 0.0)
np.maximum(d, 0.0, self.d) # (2/19/13, in place)
#-------------------------------------------------
# Find where d <= 0 and save for later (9/23/14)
#-------------------------------------------------
self.d_is_pos = (self.d > 0)
self.d_is_neg = np.invert( self.d_is_pos )
# update_flow_depth
#-------------------------------------------------------------------
def update_free_surface_slope(self):
#-----------------------------------------------------------
# Notes: It is assumed that the flow directions don't
# change even though the free surface is changing.
#-----------------------------------------------------------
delta_d = (self.d - self.d[self.d8.parent_IDs])
self.S_free[:] = self.S_bed + (delta_d / self.d8.ds)
#--------------------------------------------
# Don't do this; negative slopes are needed
# to decelerate flow in dynamic wave case
# and for backwater effects.
#--------------------------------------------
# Set negative slopes to zero
#------------------------------
### self.S_free = np.maximum(self.S_free, 0)
# update_free_surface_slope()
#-------------------------------------------------------------------
def update_shear_stress(self):
#--------------------------------------------------------
# Notes: 9/9/14. Added so shear stress could be shared.
# This uses the depth-slope product.
#--------------------------------------------------------
if (self.KINEMATIC_WAVE):
slope = self.S_bed
else:
slope = self.S_free
self.tau[:] = self.rho_H2O * self.g * self.d * slope
# update_shear_stress()
#-------------------------------------------------------------------
def update_shear_speed(self):
#--------------------------------------------------------
# Notes: 9/9/14. Added so shear speed could be shared.
#--------------------------------------------------------
self.u_star[:] = np.sqrt( self.tau / self.rho_H2O )
# update_shear_speed()
#-------------------------------------------------------------------
def update_trapezoid_Rh(self):
#-------------------------------------------------------------
# Notes: Compute the hydraulic radius of a trapezoid that:
# (1) has a bed width of wb >= 0 (0 for triangular)
# (2) has a bank angle of theta (0 for rectangular)
# (3) is filled with water to a depth of d.
# The units of wb and d are meters. The units of
# theta are assumed to be degrees and are converted.
#-------------------------------------------------------------
# NB! wb should never be zero, so P_wet can never be 0,
# which would produce a NaN (divide by zero).
#-------------------------------------------------------------
# See Notes for TF_Tan function in utils_TF.pro
# AW = d * (wb + (d * TF_Tan(theta_rad)) )
#-------------------------------------------------------------
# 9/9/14. Bug fix. Angles were already in radians but
# were converted to radians again.
#--------------------------------------------------------------
#---------------------------------------------------------
# Compute hydraulic radius grid for trapezoidal channels
#-----------------------------------------------------------
# Note: angles were read as degrees & converted to radians
#-----------------------------------------------------------
d = self.d # (local synonyms)
wb = self.width # (trapezoid bottom width)
L2 = d * np.tan( self.angle )
A_wet = d * (wb + L2)
P_wet = wb + (np.float64(2) * d / np.cos(self.angle) )
#---------------------------------------------------
# At noflow_IDs (e.g. edges) P_wet may be zero
# so do this to avoid "divide by zero". (10/29/11)
#---------------------------------------------------
P_wet[ self.d8.noflow_IDs ] = np.float64(1)
Rh = (A_wet / P_wet)
#--------------------------------
# w = np.where(P_wet == 0)
# print 'In update_trapezoid_Rh():'
# print ' P_wet= 0 at', w[0].size, 'cells'
#------------------------------------
# Force edge pixels to have Rh = 0.
# This will make u = 0 there also.
#------------------------------------
Rh[ self.d8.noflow_IDs ] = np.float64(0)
## w = np.where(wb <= 0)
## nw = np.size(w[0])
## if (nw > 0): Rh[w] = np.float64(0)
self.Rh[:] = Rh
self.A_wet[:] = A_wet ## (Now shared: 9/9/14)
self.P_wet[:] = P_wet ## (Now shared: 9/9/14)
#---------------
# For testing
#--------------
## print 'dmin, dmax =', d.min(), d.max()
## print 'wmin, wmax =', wb.min(), wb.max()
## print 'amin, amax =', self.angle.min(), self.angle.max()
# update_trapezoid_Rh()
#-------------------------------------------------------------------
def update_friction_factor(self):
#----------------------------------------
# Note: Added on 9/9/14 to streamline.
#----------------------------------------------------------
# Note: f = half of the Fanning friction factor
# d = flow depth [m]
# z0 = roughness length
# S = bed slope (assumed equal to friction slope)
# g = 9.81 = gravitation constant [m/s^2]
#---------------------------------------------------------
# For law of the wall:
# kappa = 0.41 = von Karman's constant
# aval = 0.48 = integration constant
# law_const = sqrt(g)/kappa = 7.6393d
# smoothness = (aval / z0) * d
# f = (kappa / alog(smoothness))^2d
# tau_bed = rho_w * f * u^2 = rho_w * g * d * S
# d, S, and z0 can be arrays.
# To make default z0 correspond to default
# Manning's n, can use this approximation:
# z0 = a * (2.34 * sqrt(9.81) * n / kappa)^6d
# For n=0.03, this gives: z0 = 0.011417
#########################################################
# However, for n=0.3, it gives: z0 = 11417.413
# which is 11.4 km! So the approximation only
# holds within some range of values.
#--------------------------------------------------------
###############################################################
# cProfile: This method took: 0.369 secs for topoflow_test()
###############################################################
#--------------------------------------
# Find where (d <= 0). g=good, b=bad
#--------------------------------------
wg = self.d_is_pos
wb = self.d_is_neg
# wg = ( self.d > 0 )
# wb = np.invert( wg )
#-----------------------------
# Compute f for Manning case
#-----------------------------------------
# This makes f=0 and du=0 where (d <= 0)
#-----------------------------------------
if (self.MANNING):
n2 = self.nval ** np.float64(2)
self.f[ wg ] = self.g * (n2[wg] / (self.d[wg] ** self.one_third))
self.f[ wb ] = np.float64(0)
#---------------------------------
# Compute f for Law of Wall case
#---------------------------------
if (self.LAW_OF_WALL):
#------------------------------------------------
# Make sure (smoothness > 1) before taking log.
# Should issue a warning if this is used.
#------------------------------------------------
smoothness = (self.aval / self.z0val) * self.d
np.maximum(smoothness, np.float64(1.1), smoothness) # (in place)
self.f[wg] = (self.kappa / np.log(smoothness[wg])) ** np.float64(2)
self.f[wb] = np.float64(0)
##############################################################
# cProfile: This method took: 0.93 secs for topoflow_test()
##############################################################
# #--------------------------------------
# # Find where (d <= 0). g=good, b=bad
# #--------------------------------------
# wg = np.where( self.d > 0 )
# ng = np.size( wg[0])
# wb = np.where( self.d <= 0 )
# nb = np.size( wb[0] )
#
# #-----------------------------
# # Compute f for Manning case
# #-----------------------------------------
# # This makes f=0 and du=0 where (d <= 0)
# #-----------------------------------------
# if (self.MANNING):
# n2 = self.nval ** np.float64(2)
# if (ng != 0):
# self.f[wg] = self.g * (n2[wg] / (self.d[wg] ** self.one_third))
# if (nb != 0):
# self.f[wb] = np.float64(0)
#
# #---------------------------------
# # Compute f for Law of Wall case
# #---------------------------------
# if (self.LAW_OF_WALL):
# #------------------------------------------------
# # Make sure (smoothness > 1) before taking log.
# # Should issue a warning if this is used.
# #------------------------------------------------
# smoothness = (self.aval / self.z0val) * self.d
# np.maximum(smoothness, np.float64(1.1), smoothness) # (in place)
# ## smoothness = np.maximum(smoothness, np.float64(1.1))
# if (ng != 0):
# self.f[wg] = (self.kappa / np.log(smoothness[wg])) ** np.float64(2)
# if (nb != 0):
# self.f[wb] = np.float64(0)
#---------------------------------------------
# We could share the Fanning friction factor
#---------------------------------------------
### self.fanning = (np.float64(2) * self.f)
# update_friction_factor()
#-------------------------------------------------------------------
def update_velocity(self):
#---------------------------------------------------------
# Note: Do nothing now unless this method is overridden
# by a particular method of computing velocity.
#---------------------------------------------------------
print "Warning: update_velocity() method is inactive."
# print 'KINEMATIC WAVE =', self.KINEMATIC_WAVE
# print 'DIFFUSIVE WAVE =', self.DIFFUSIVE_WAVE
# print 'DYNAMIC WAVE =', self.DYNAMIC_WAVE
# update_velocity()
#-------------------------------------------------------------------
def update_velocity_on_edges(self):
#---------------------------------
# Force edge pixels to have u=0.
#----------------------------------------
# Large slope around 1 flows into small
# slope & leads to a negative velocity.
#----------------------------------------
self.u[ self.d8.noflow_IDs ] = np.float64(0)
# update_velocity_on_edges()
#-------------------------------------------------------------------
def update_froude_number(self):
#----------------------------------------------------------
# Notes: 9/9/14. Added so Froude number could be shared.
# This use of wg & wb reduced cProfile time from:
# 0.644 sec to: 0.121. (9/23/14)
#----------------------------------------------------------
# g = good, b = bad
#--------------------
wg = self.d_is_pos
wb = self.d_is_neg
self.froude[ wg ] = self.u[wg] / np.sqrt( self.g * self.d[wg] )
self.froude[ wb ] = np.float64(0)
# update_froude_number()
#-------------------------------------------------------------
def update_outlet_values(self):
#-------------------------------------------------
# Save computed values at outlet, which are used
# by the TopoFlow driver.
#-----------------------------------------------------
# Note that Q_outlet, etc. are defined as 0D numpy
# arrays to make them "mutable scalars" (i.e.
# this allows changes to be seen by other components
# who have a reference. To preserver the reference,
# however, we must use fill() to assign a new value.
#-----------------------------------------------------
Q_outlet = self.Q[ self.outlet_ID ]
u_outlet = self.u[ self.outlet_ID ]
d_outlet = self.d[ self.outlet_ID ]
f_outlet = self.f[ self.outlet_ID ]
self.Q_outlet.fill( Q_outlet )
self.u_outlet.fill( u_outlet )
self.d_outlet.fill( d_outlet )
self.f_outlet.fill( f_outlet )
## self.Q_outlet.fill( self.Q[ self.outlet_ID ] )
## self.u_outlet.fill( self.u[ self.outlet_ID ] )
## self.d_outlet.fill( self.d[ self.outlet_ID ] )
## self.f_outlet.fill( self.f[ self.outlet_ID ] )
## self.Q_outlet = self.Q[ self.outlet_ID ]
## self.u_outlet = self.u[ self.outlet_ID ]
## self.d_outlet = self.d[ self.outlet_ID ]
## self.f_outlet = self.f[ self.outlet_ID ]
## self.Q_outlet = self.Q.flat[self.outlet_ID]
## self.u_outlet = self.u.flat[self.outlet_ID]
## self.d_outlet = self.d.flat[self.outlet_ID]
## self.f_outlet = self.f.flat[self.outlet_ID]
# update_outlet_values()
#-------------------------------------------------------------
def update_peak_values(self):
if (self.Q_outlet > self.Q_peak):
self.Q_peak.fill( self.Q_outlet )
self.T_peak.fill( self.time_min ) # (time to peak)
#---------------------------------------
if (self.u_outlet > self.u_peak):
self.u_peak.fill( self.u_outlet )
self.Tu_peak.fill( self.time_min )
#---------------------------------------
if (self.d_outlet > self.d_peak):
self.d_peak.fill( self.d_outlet )
self.Td_peak.fill( self.time_min )
## if (self.Q_outlet > self.Q_peak):
## self.Q_peak = self.Q_outlet
## self.T_peak = self.time_min # (time to peak)
## #-----------------------------------
## if (self.u_outlet > self.u_peak):
## self.u_peak = self.u_outlet
## self.Tu_peak = self.time_min
## #-----------------------------------
## if (self.d_outlet > self.d_peak):
## self.d_peak = self.d_outlet
## self.Td_peak = self.time_min
# update_peak_values()
#-------------------------------------------------------------
def update_Q_out_integral(self):
#--------------------------------------------------------
# Note: Renamed "volume_out" to "vol_Q" for consistency
# with vol_P, vol_SM, vol_IN, vol_ET, etc. (5/18/12)
#--------------------------------------------------------
self.vol_Q += (self.Q_outlet * self.dt) ## Experiment: 5/19/12.
## self.vol_Q += (self.Q[self.outlet_ID] * self.dt)
# update_Q_out_integral()
#-------------------------------------------------------------
def update_mins_and_maxes(self, REPORT=False):
#--------------------------------------
# Get mins and max over entire domain
#--------------------------------------
## Q_min = self.Q.min()
## Q_max = self.Q.max()
## #---------------------
## u_min = self.u.min()
## u_max = self.u.max()
## #---------------------
## d_min = self.d.min()
## d_max = self.d.max()
#--------------------------------------------
# Exclude edges where mins are always zero.
#--------------------------------------------
nx = self.nx
ny = self.ny
Q_min = self.Q[1:(ny - 2)+1,1:(nx - 2)+1].min()
Q_max = self.Q[1:(ny - 2)+1,1:(nx - 2)+1].max()
#-------------------------------------------------
u_min = self.u[1:(ny - 2)+1,1:(nx - 2)+1].min()
u_max = self.u[1:(ny - 2)+1,1:(nx - 2)+1].max()
#-------------------------------------------------
d_min = self.d[1:(ny - 2)+1,1:(nx - 2)+1].min()
d_max = self.d[1:(ny - 2)+1,1:(nx - 2)+1].max()
#-------------------------------------------------
# (2/6/13) This preserves "mutable scalars" that
# can be accessed as refs by other components.
#-------------------------------------------------
if (Q_min < self.Q_min):
self.Q_min.fill( Q_min )
if (Q_max > self.Q_max):
self.Q_max.fill( Q_max )
#------------------------------
if (u_min < self.u_min):
self.u_min.fill( u_min )
if (u_max > self.u_max):
self.u_max.fill( u_max )
#------------------------------
if (d_min < self.d_min):
self.d_min.fill( d_min )
if (d_max > self.d_max):
self.d_max.fill( d_max )
#-------------------------------------------------
# (2/6/13) This preserves "mutable scalars" that
# can be accessed as refs by other components.
#-------------------------------------------------
## self.Q_min.fill( np.minimum( self.Q_min, Q_min ) )
## self.Q_max.fill( np.maximum( self.Q_max, Q_max ) )
## #---------------------------------------------------
## self.u_min.fill( np.minimum( self.u_min, u_min ) )
## self.u_max.fill( np.maximum( self.u_max, u_max ) )
## #---------------------------------------------------
## self.d_min.fill( np.minimum( self.d_min, d_min ) )
## self.d_max.fill( np.maximum( self.d_max, d_max ) )
#-------------------------------------------------
# (2/6/13) This preserves "mutable scalars" that
# can be accessed as refs by other components.
#-------------------------------------------------
## self.Q_min.fill( min( self.Q_min, Q_min ) )
## self.Q_max.fill( max( self.Q_max, Q_max ) )
## #---------------------------------------------------
## self.u_min.fill( min( self.u_min, u_min ) )
## self.u_max.fill( max( self.u_max, u_max ) )
## #---------------------------------------------------
## self.d_min.fill( min( self.d_min, d_min ) )
## self.d_max.fill( max( self.d_max, d_max ) )
#----------------------------------------------
# (2/6/13) This produces "immutable scalars".
#----------------------------------------------
## self.Q_min = self.Q.min()
## self.Q_max = self.Q.max()
## self.u_min = self.u.min()
## self.u_max = self.u.max()
## self.d_min = self.d.min()
## self.d_max = self.d.max()
if (REPORT):
print 'In channels_base.update_mins_and_maxes():'
print '(dmin, dmax) =', self.d_min, self.d_max
print '(umin, umax) =', self.u_min, self.u_max
print '(Qmin, Qmax) =', self.Q_min, self.Q_max
print ' '
# update_mins_and_maxes()
#-------------------------------------------------------------------
def check_flow_depth(self):
OK = True
d = self.d
dt = self.dt
nx = self.nx #################
#---------------------------------
# All all flow depths positive ?
#---------------------------------
wbad = np.where( np.logical_or( d < 0.0, np.logical_not(np.isfinite(d)) ))
nbad = np.size( wbad[0] )
if (nbad == 0):
return OK
OK = False
dmin = d[wbad].min()
star_line = '*******************************************'
msg = [ star_line, \
'ERROR: Simulation aborted.', ' ', \
'Negative depth found: ' + str(dmin), \
'Time step may be too large.', \
'Time step: ' + str(dt) + ' [s]', ' ']
for k in xrange(len(msg)):
print msg[k]
#-------------------------------------------
# If not too many, print actual velocities
#-------------------------------------------
if (nbad < 30):
brow = wbad[0][0]
bcol = wbad[1][0]
## badi = wbad[0]
## bcol = (badi % nx)
## brow = (badi / nx)
crstr = str(bcol) + ', ' + str(brow)
msg = ['(Column, Row): ' + crstr, \
'Flow depth: ' + str(d[brow, bcol])]
for k in xrange(len(msg)):
print msg[k]
print star_line
print ' '
return OK
# check_flow_depth
#-------------------------------------------------------------------
def check_flow_velocity(self):
OK = True
u = self.u
dt = self.dt
nx = self.nx
#--------------------------------
# Are all velocities positive ?
#--------------------------------
wbad = np.where( np.logical_or( u < 0.0, np.logical_not(np.isfinite(u)) ))
nbad = np.size( wbad[0] )
if (nbad == 0):
return OK
OK = False
umin = u[wbad].min()
star_line = '*******************************************'
msg = [ star_line, \
'ERROR: Simulation aborted.', ' ', \
'Negative or NaN velocity found: ' + str(umin), \
'Time step may be too large.', \
'Time step: ' + str(dt) + ' [s]', ' ']
for k in xrange(len(msg)):
print msg[k]
#-------------------------------------------
# If not too many, print actual velocities
#-------------------------------------------
if (nbad < 30):
brow = wbad[0][0]
bcol = wbad[1][0]
## badi = wbad[0]
## bcol = (badi % nx)
## brow = (badi / nx)
crstr = str(bcol) + ', ' + str(brow)
msg = ['(Column, Row): ' + crstr, \
'Velocity: ' + str(u[brow, bcol])]
for k in xrange(len(msg)):
print msg[k]
print star_line
print ' '
return OK
## umin = u[wbad].min()
## badi = wbad[0]
## bcol = (badi % nx)
## brow = (badi / nx)
## crstr = str(bcol) + ', ' + str(brow)
## msg = np.array([' ', \
## '*******************************************', \
## 'ERROR: Simulation aborted.', ' ', \
## 'Negative velocity found: ' + str(umin), \
## 'Time step may be too large.', ' ', \
## '(Column, Row): ' + crstr, \
## 'Velocity: ' + str(u[badi]), \
## 'Time step: ' + str(dt) + ' [s]', \
## '*******************************************', ' '])
## for k in xrange( np.size(msg) ):
## print msg[k]
## return OK
# check_flow_velocity
#-------------------------------------------------------------------
def open_input_files(self):
# This doesn't work, because file_unit doesn't get full path. (10/28/11)
# start_dir = os.getcwd()
# os.chdir( self.in_directory )
# print '### start_dir =', start_dir
# print '### in_directory =', self.in_directory
in_files = ['slope_file', 'nval_file', 'z0val_file',
'width_file', 'angle_file', 'sinu_file', 'd0_file']
self.prepend_directory( in_files, INPUT=True )
# self.slope_file = self.in_directory + self.slope_file
# self.nval_file = self.in_directory + self.nval_file
# self.z0val_file = self.in_directory + self.z0val_file
# self.width_file = self.in_directory + self.width_file
# self.angle_file = self.in_directory + self.angle_file
# self.sinu_file = self.in_directory + self.sinu_file
# self.d0_file = self.in_directory + self.d0_file
#self.code_unit = model_input.open_file(self.code_type, self.code_file)
self.slope_unit = model_input.open_file(self.slope_type, self.slope_file)
if (self.MANNING):
self.nval_unit = model_input.open_file(self.nval_type, self.nval_file)
if (self.LAW_OF_WALL):
self.z0val_unit = model_input.open_file(self.z0val_type, self.z0val_file)
self.width_unit = model_input.open_file(self.width_type, self.width_file)
self.angle_unit = model_input.open_file(self.angle_type, self.angle_file)
self.sinu_unit = model_input.open_file(self.sinu_type, self.sinu_file)
self.d0_unit = model_input.open_file(self.d0_type, self.d0_file)
# os.chdir( start_dir )
# open_input_files()
#-------------------------------------------------------------------
def read_input_files(self):
#---------------------------------------------------
# The flow codes are always a grid, size of DEM.
#---------------------------------------------------
# NB! model_input.py also has a read_grid() function.
#---------------------------------------------------
rti = self.rti
## print 'Reading D8 flow grid (in CHANNELS)...'
## self.code = rtg_files.read_grid(self.code_file, rti,
## RTG_type='BYTE')
## print ' '
#-------------------------------------------------------
# All grids are assumed to have a data type of Float32.
#-------------------------------------------------------
slope = model_input.read_next(self.slope_unit, self.slope_type, rti)
if (slope != None): self.slope = slope
# If EOF was reached, hopefully numpy's "fromfile"
# returns None, so that the stored value will be
# the last value that was read.
if (self.MANNING):
nval = model_input.read_next(self.nval_unit, self.nval_type, rti)
if (nval != None):
self.nval = nval
self.nval_min = nval.min()
self.nval_max = nval.max()
if (self.LAW_OF_WALL):
z0val = model_input.read_next(self.z0val_unit, self.z0val_type, rti)
if (z0val != None):
self.z0val = z0val
self.z0val_min = z0val.min()
self.z0val_max = z0val.max()
width = model_input.read_next(self.width_unit, self.width_type, rti)
if (width != None): self.width = width
angle = model_input.read_next(self.angle_unit, self.angle_type, rti)
if (angle != None):
#-----------------------------------------------
# Convert bank angles from degrees to radians.
#-----------------------------------------------
self.angle = angle * self.deg_to_rad # [radians]
### self.angle = angle # (before 9/9/14)
sinu = model_input.read_next(self.sinu_unit, self.sinu_type, rti)
if (sinu != None): self.sinu = sinu
d0 = model_input.read_next(self.d0_unit, self.d0_type, rti)
if (d0 != None): self.d0 = d0
## code = model_input.read_grid(self.code_unit, \
## self.code_type, rti, dtype='UInt8')
## if (code != None): self.code = code
# read_input_files()
#-------------------------------------------------------------------
def close_input_files(self):
# if not(self.slope_unit.closed):
# if (self.slope_unit != None):
#-------------------------------------------------
# NB! self.code_unit was never defined as read.
#-------------------------------------------------
# if (self.code_type != 'scalar'): self.code_unit.close()
if (self.slope_type != 'Scalar'): self.slope_unit.close()
if (self.MANNING):
if (self.nval_type != 'Scalar'): self.nval_unit.close()
if (self.LAW_OF_WALL):
if (self.z0val_type != 'Scalar'): self.z0val_unit.close()
if (self.width_type != 'Scalar'): self.width_unit.close()
if (self.angle_type != 'Scalar'): self.angle_unit.close()
if (self.sinu_type != 'Scalar'): self.sinu_unit.close()
if (self.d0_type != 'Scalar'): self.d0_unit.close()
## if (self.slope_file != ''): self.slope_unit.close()
## if (self.MANNING):
## if (self.nval_file != ''): self.nval_unit.close()
## if (self.LAW_OF_WALL):
## if (self.z0val_file != ''): self.z0val_unit.close()
## if (self.width_file != ''): self.width_unit.close()
## if (self.angle_file != ''): self.angle_unit.close()
## if (self.sinu_file != ''): self.sinu_unit.close()
## if (self.d0_file != ''): self.d0_unit.close()
# close_input_files()
#-------------------------------------------------------------------
def update_outfile_names(self):
#-------------------------------------------------
# Notes: Append out_directory to outfile names.
#-------------------------------------------------
self.Q_gs_file = (self.out_directory + self.Q_gs_file)
self.u_gs_file = (self.out_directory + self.u_gs_file)
self.d_gs_file = (self.out_directory + self.d_gs_file)
self.f_gs_file = (self.out_directory + self.f_gs_file)
#--------------------------------------------------------
self.Q_ts_file = (self.out_directory + self.Q_ts_file)
self.u_ts_file = (self.out_directory + self.u_ts_file)
self.d_ts_file = (self.out_directory + self.d_ts_file)
self.f_ts_file = (self.out_directory + self.f_ts_file)
# update_outfile_names()
#-------------------------------------------------------------------
def bundle_output_files(self):
###################################################
# NOT READY YET. Need "get_long_name()" and a new
# version of "get_var_units". (9/21/14)
###################################################
#-------------------------------------------------------------
# Bundle the output file info into an array for convenience.
# Then we just need one open_output_files(), in BMI_base.py,
# and one close_output_files(). Less to maintain. (9/21/14)
#-------------------------------------------------------------
# gs = grid stack, ts = time series, ps = profile series.
#-------------------------------------------------------------
self.out_files = [
{var_name:'Q',
save_gs:self.SAVE_Q_GRIDS, gs_file:self.Q_gs_file,
save_ts:self.SAVE_Q_PIXELS, ts_file:self.Q_ts_file,
long_name:get_long_name('Q'), units_name:get_var_units('Q')},
#-----------------------------------------------------------------
{var_name:'u',
save_gs:self.SAVE_U_GRIDS, gs_file:self.u_gs_file,
save_ts:self.SAVE_U_PIXELS, ts_file:self.u_ts_file,
long_name:get_long_name('u'), units_name:get_var_units('u')},
#-----------------------------------------------------------------
{var_name:'d',
save_gs:self.SAVE_D_GRIDS, gs_file:self.d_gs_file,
save_ts:self.SAVE_D_PIXELS, ts_file:self.d_ts_file,
long_name:get_long_name('d'), units_name:get_var_units('d')},
#-----------------------------------------------------------------
{var_name:'f',
save_gs:self.SAVE_F_GRIDS, gs_file:self.f_gs_file,
save_ts:self.SAVE_F_PIXELS, ts_file:self.f_ts_file,
long_name:get_long_name('f'), units_name:get_var_units('f')} ]
# bundle_output_files
#-------------------------------------------------------------------
def open_output_files(self):
model_output.check_netcdf()
self.update_outfile_names()
## self.bundle_output_files()
## print 'self.SAVE_Q_GRIDS =', self.SAVE_Q_GRIDS
## print 'self.SAVE_U_GRIDS =', self.SAVE_U_GRIDS
## print 'self.SAVE_D_GRIDS =', self.SAVE_D_GRIDS
## print 'self.SAVE_F_GRIDS =', self.SAVE_F_GRIDS
## #---------------------------------------------------
## print 'self.SAVE_Q_PIXELS =', self.SAVE_Q_PIXELS
## print 'self.SAVE_U_PIXELS =', self.SAVE_U_PIXELS
## print 'self.SAVE_D_PIXELS =', self.SAVE_D_PIXELS
## print 'self.SAVE_F_PIXELS =', self.SAVE_F_PIXELS
# IDs = self.outlet_IDs
# for k in xrange( len(self.out_files) ):
# #--------------------------------------
# # Open new files to write grid stacks
# #--------------------------------------
# if (self.out_files[k].save_gs):
# model_output.open_new_gs_file( self, self.out_files[k], self.rti )
# #--------------------------------------
# # Open new files to write time series
# #--------------------------------------
# if (self.out_files[k].save_ts):
# model_output.open_new_ts_file( self, self.out_files[k], IDs )
#--------------------------------------
# Open new files to write grid stacks
#--------------------------------------
if (self.SAVE_Q_GRIDS):
model_output.open_new_gs_file( self, self.Q_gs_file, self.rti,
var_name='Q',
long_name='volumetric_discharge',
units_name='m^3/s')
if (self.SAVE_U_GRIDS):
model_output.open_new_gs_file( self, self.u_gs_file, self.rti,
var_name='u',
long_name='mean_channel_flow_velocity',
units_name='m/s')
if (self.SAVE_D_GRIDS):
model_output.open_new_gs_file( self, self.d_gs_file, self.rti,
var_name='d',
long_name='max_channel_flow_depth',
units_name='m')
if (self.SAVE_F_GRIDS):
model_output.open_new_gs_file( self, self.f_gs_file, self.rti,
var_name='f',
long_name='friction_factor',
units_name='none')
#--------------------------------------
# Open new files to write time series
#--------------------------------------
IDs = self.outlet_IDs
if (self.SAVE_Q_PIXELS):
model_output.open_new_ts_file( self, self.Q_ts_file, IDs,
var_name='Q',
long_name='volumetric_discharge',
units_name='m^3/s')
if (self.SAVE_U_PIXELS):
model_output.open_new_ts_file( self, self.u_ts_file, IDs,
var_name='u',
long_name='mean_channel_flow_velocity',
units_name='m/s')
if (self.SAVE_D_PIXELS):
model_output.open_new_ts_file( self, self.d_ts_file, IDs,
var_name='d',
long_name='max_channel_flow_depth',
units_name='m')
if (self.SAVE_F_PIXELS):
model_output.open_new_ts_file( self, self.f_ts_file, IDs,
var_name='f',
long_name='friction_factor',
units_name='none')
# open_output_files()
#-------------------------------------------------------------------
def write_output_files(self, time_seconds=None):
#---------------------------------------------------------
# Notes: This function was written to use only model
# time (maybe from a caller) in seconds, and
# the save_grid_dt and save_pixels_dt parameters
# read by read_cfg_file().
#
# read_cfg_file() makes sure that all of
# the "save_dts" are larger than or equal to the
# process dt.
#---------------------------------------------------------
#-----------------------------------------
# Allows time to be passed from a caller
#-----------------------------------------
if (time_seconds is None):
time_seconds = self.time_sec
model_time = int(time_seconds)
#----------------------------------------
# Save computed values at sampled times
#----------------------------------------
if (model_time % int(self.save_grid_dt) == 0):
self.save_grids()
if (model_time % int(self.save_pixels_dt) == 0):
self.save_pixel_values()
#----------------------------------------
# Save computed values at sampled times
#----------------------------------------
## if ((self.time_index % self.grid_save_step) == 0):
## self.save_grids()
## if ((self.time_index % self.pixel_save_step) == 0):
## self.save_pixel_values()
# write_output_files()
#-------------------------------------------------------------------
def close_output_files(self):
if (self.SAVE_Q_GRIDS): model_output.close_gs_file( self, 'Q')
if (self.SAVE_U_GRIDS): model_output.close_gs_file( self, 'u')
if (self.SAVE_D_GRIDS): model_output.close_gs_file( self, 'd')
if (self.SAVE_F_GRIDS): model_output.close_gs_file( self, 'f')
#---------------------------------------------------------------
if (self.SAVE_Q_PIXELS): model_output.close_ts_file( self, 'Q')
if (self.SAVE_U_PIXELS): model_output.close_ts_file( self, 'u')
if (self.SAVE_D_PIXELS): model_output.close_ts_file( self, 'd')
if (self.SAVE_F_PIXELS): model_output.close_ts_file( self, 'f')
# close_output_files()
#-------------------------------------------------------------------
def save_grids(self):
#-----------------------------------
# Save grid stack to a netCDF file
#---------------------------------------------
# Note that add_grid() methods will convert
# var from scalar to grid now, if necessary.
#---------------------------------------------
if (self.SAVE_Q_GRIDS):
model_output.add_grid( self, self.Q, 'Q', self.time_min )
if (self.SAVE_U_GRIDS):
model_output.add_grid( self, self.u, 'u', self.time_min )
if (self.SAVE_D_GRIDS):
model_output.add_grid( self, self.d, 'd', self.time_min )
if (self.SAVE_F_GRIDS):
model_output.add_grid( self, self.f, 'f', self.time_min )
# save_grids()
#-------------------------------------------------------------------
def save_pixel_values(self): ##### save_time_series_data(self) #######
IDs = self.outlet_IDs
time = self.time_min #####
#-------------
# New method
#-------------
if (self.SAVE_Q_PIXELS):
model_output.add_values_at_IDs( self, time, self.Q, 'Q', IDs )
if (self.SAVE_U_PIXELS):
model_output.add_values_at_IDs( self, time, self.u, 'u', IDs )
if (self.SAVE_D_PIXELS):
model_output.add_values_at_IDs( self, time, self.d, 'd', IDs )
if (self.SAVE_F_PIXELS):
model_output.add_values_at_IDs( self, time, self.f, 'f', IDs )
# save_pixel_values()
#-------------------------------------------------------------------
def manning_formula(self):
#---------------------------------------------------------
# Notes: R = (A/P) = hydraulic radius [m]
# N = Manning's roughness coefficient
# (usually in the range 0.012 to 0.035)
# S = bed slope or free slope
# R,S, and N may be 2D arrays.
# If length units are all *feet*, then an extra
# factor of 1.49 must be applied. If units are
# meters, no such factor is needed.
# Note that Q = Ac * u, where Ac is cross-section
# area. For a trapezoid, Ac does not equal w*d.
#---------------------------------------------------------
if (self.KINEMATIC_WAVE):
S = self.S_bed
else:
S = self.S_free
u = (self.Rh ** self.two_thirds) * np.sqrt(S) / self.nval
#--------------------------------------------------------
# Add a hydraulic jump option for when u gets too big ?
#--------------------------------------------------------
return u
# manning_formula()
#-------------------------------------------------------------------
def law_of_the_wall(self):
#---------------------------------------------------------
# Notes: u = flow velocity [m/s]
# d = flow depth [m]
# z0 = roughness length
# S = bed slope or free slope
# g = 9.81 = gravitation constant [m/s^2]
# kappa = 0.41 = von Karman's constant
# aval = 0.48 = integration constant
# law_const = sqrt(g)/kappa = 7.6393d
# smoothness = (aval / z0) * d
# f = (kappa / alog(smoothness))^2d
# tau_bed = rho_w * f * u^2 = rho_w * g * d * S
# d, S, and z0 can be arrays.
# To make default z0 correspond to default
# Manning's n, can use this approximation:
# z0 = a * (2.34 * sqrt(9.81) * n / kappa)^6d
# For n=0.03, this gives: z0 = 0.011417
#########################################################
# However, for n=0.3, it gives: z0 = 11417.413
# which is 11.4 km! So the approximation only
# holds within some range of values.
#--------------------------------------------------------
if (self.KINEMATIC_WAVE):
S = self.S_bed
else:
S = self.S_free
smoothness = (self.aval / self.z0val) * self.d
#------------------------------------------------
# Make sure (smoothness > 1) before taking log.
# Should issue a warning if this is used.
#------------------------------------------------
smoothness = np.maximum(smoothness, np.float64(1.1))
u = self.law_const * np.sqrt(self.Rh * S) * np.log(smoothness)
#--------------------------------------------------------
# Add a hydraulic jump option for when u gets too big ?
#--------------------------------------------------------
return u
# law_of_the_wall()
#-------------------------------------------------------------------
def print_status_report(self):
#----------------------------------------------------
# Wherever depth is less than z0, assume that water
# is not flowing and set u and Q to zero.
# However, we also need (d gt 0) to avoid a divide
# by zero problem, even when numerators are zero.
#----------------------------------------------------
# FLOWING = (d > (z0/aval))
#*** FLOWING[noflow_IDs] = False ;******
wflow = np.where( FLOWING != 0 )
n_flow = np.size( wflow[0] )
n_pixels = self.rti.n_pixels
percent = np.float64(100.0) * (np.float64(n_flow) / n_pixels)
fstr = ('%5.1f' % percent) + '%'
# fstr = idl_func.string(percent, format='(F5.1)').strip() + '%'
print ' Percentage of pixels with flow = ' + fstr
print ' '
self.update_mins_and_maxes(REPORT=True)
wmax = np.where(self.Q == self.Q_max)
nwmax = np.size(wmax[0])
print ' Max(Q) occurs at: ' + str( wmax[0] )
#print,' Max attained at ', nwmax, ' pixels.'
print ' '
print '-------------------------------------------------'
# print_status_report()
#-------------------------------------------------------------------
def remove_bad_slopes(self, FLOAT=False):
#------------------------------------------------------------
# Notes: The main purpose of this routine is to find
# pixels that have nonpositive slopes and replace
# then with the smallest value that occurs anywhere
# in the input slope grid. For example, pixels on
# the edges of the DEM will have a slope of zero.
# With the Kinematic Wave option, flow cannot leave
# a pixel that has a slope of zero and the depth
# increases in an unrealistic manner to create a
# spike in the depth grid.
# It would be better, of course, if there were
# no zero-slope pixels in the DEM. We could use
# an "Imposed gradient DEM" to get slopes or some
# method of "profile smoothing".
# It is possible for the flow code to be nonzero
# at a pixel that has NaN for its slope. For these
# pixels, we also set the slope to our min value.
# 7/18/05. Broke this out into separate procedure.
#------------------------------------------------------------
#-----------------------------------
# Are there any "bad" pixels ?
# If not, return with no messages.
#-----------------------------------
wb = np.where(np.logical_or((self.slope <= 0.0), \
np.logical_not(np.isfinite(self.slope))))
nbad = np.size(wb[0])
print 'size(slope) =', np.size(self.slope)
print 'size(wb) =', nbad
wg = np.where(np.invert(np.logical_or((self.slope <= 0.0), \
np.logical_not(np.isfinite(self.slope)))))
ngood = np.size(wg[0])
if (nbad == 0) or (ngood == 0):
return
#---------------------------------------------
# Find smallest positive value in slope grid
# and replace the "bad" values with smin.
#---------------------------------------------
print '-------------------------------------------------'
print 'WARNING: Zero or negative slopes found.'
print ' Replacing them with smallest slope.'
print ' Use "Profile smoothing tool" instead.'
S_min = self.slope[wg].min()
S_max = self.slope[wg].max()
print ' min(S) = ' + str(S_min)
print ' max(S) = ' + str(S_max)
print '-------------------------------------------------'
print ' '
self.slope[wb] = S_min
#--------------------------------
# Convert data type to double ?
#--------------------------------
if (FLOAT):
self.slope = np.float32(self.slope)
else:
self.slope = np.float64(self.slope)
# remove_bad_slopes
#-------------------------------------------------------------------
#-------------------------------------------------------------------
def Trapezoid_Rh(d, wb, theta):
#-------------------------------------------------------------
# Notes: Compute the hydraulic radius of a trapezoid that:
# (1) has a bed width of wb >= 0 (0 for triangular)
# (2) has a bank angle of theta (0 for rectangular)
# (3) is filled with water to a depth of d.
# The units of wb and d are meters. The units of
# theta are assumed to be degrees and are converted.
#-------------------------------------------------------------
# NB! wb should never be zero, so PW can never be 0,
# which would produce a NaN (divide by zero).
#-------------------------------------------------------------
# See Notes for TF_Tan function in utils_TF.pro
# AW = d * (wb + (d * TF_Tan(theta_rad)) )
#-------------------------------------------------------------
theta_rad = (theta * np.pi / 180.0)
AW = d * (wb + (d * np.tan(theta_rad)) )
PW = wb + (np.float64(2) * d / np.cos(theta_rad) )
Rh = (AW / PW)
w = np.where(wb <= 0)
nw = np.size(w[0])
return Rh
# Trapezoid_Rh()
#-------------------------------------------------------------------
def Manning_Formula(Rh, S, nval):
#---------------------------------------------------------
# Notes: R = (A/P) = hydraulic radius [m]
# N = Manning's roughness coefficient
# (usually in the range 0.012 to 0.035)
# S = bed slope (assumed equal to friction slope)
# R,S, and N may be 2D arrays.
# If length units are all *feet*, then an extra
# factor of 1.49 must be applied. If units are
# meters, no such factor is needed.
# Note that Q = Ac * u, where Ac is cross-section
# area. For a trapezoid, Ac does not equal w*d.
#---------------------------------------------------------
## if (N == None): N = np.float64(0.03)
two_thirds = np.float64(2) / 3.0
u = (Rh ** two_thirds) * np.sqrt(S) / nval
#------------------------------
# Add a hydraulic jump option
# for when u gets too big ??
#------------------------------
return u
# Manning_Formula()
#-------------------------------------------------------------------
def Law_of_the_Wall(d, Rh, S, z0val):
#---------------------------------------------------------
# Notes: u = flow velocity [m/s]
# d = flow depth [m]
# z0 = roughness height
# S = bed slope (assumed equal to friction slope)
# g = 9.81 = gravitation constant [m/s^2]
# kappa = 0.41 = von Karman's constant
# aval = 0.48 = integration constant
# sqrt(g)/kappa = 7.6393d
# smoothness = (aval / z0) * d
# f = (kappa / alog(smoothness))^2d
# tau_bed = rho_w * f * u^2 = rho_w * g * d * S
# d, S, and z0 can be arrays.
# To make default z0 correspond to default
# Manning's n, can use this approximation:
# z0 = a * (2.34 * sqrt(9.81) * n / kappa)^6d
# For n=0.03, this gives: z0 = 0.011417
# However, for n=0.3, it gives: z0 = 11417.413
# which is 11.4 km! So the approximation only
# holds within some range of values.
#--------------------------------------------------------
## if (self.z0val == None):
## self.z0val = np.float64(0.011417) # (about 1 cm)
#------------------------
# Define some constants
#------------------------
g = np.float64(9.81) # (gravitation const.)
aval = np.float64(0.476) # (integration const.)
kappa = np.float64(0.408) # (von Karman's const.)
law_const = np.sqrt(g) / kappa
smoothness = (aval / z0val) * d
#-----------------------------
# Make sure (smoothness > 1)
#-----------------------------
smoothness = np.maximum(smoothness, np.float64(1.1))
u = law_const * np.sqrt(Rh * S) * np.log(smoothness)
#------------------------------
# Add a hydraulic jump option
# for when u gets too big ??
#------------------------------
return u | Java |
#include <QDebug>
#include <net/if.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include "monitor.h"
Monitor::Monitor()
{
running = 0;
}
void Monitor::start()
{
int rc;
int s;
fd_set rdfs;
int nbytes;
struct sockaddr_can addr;
struct canfd_frame frame;
struct iovec iov;
char ctrlmsg[CMSG_SPACE(sizeof(struct timeval)) + CMSG_SPACE(sizeof(__u32))];
struct msghdr msg;
struct ifreq ifr;
char* ifname = "can0";
running = 1;
s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
if (s < 0)
{
qDebug() << "Error opening socket: " << s;
stop();
return;
}
strcpy(ifr.ifr_name, ifname);
ioctl(s, SIOCGIFINDEX, &ifr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifr.ifr_ifindex;
rc = bind(s, (struct sockaddr*)&addr, sizeof(addr));
if (rc < 0)
{
qDebug() << "Error binding to interface: " << rc;
stop();
return;
}
iov.iov_base = &frame;
msg.msg_name = &addr;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = &ctrlmsg;
while (running)
{
FD_ZERO(&rdfs);
FD_SET(s, &rdfs);
rc = select(s, &rdfs, NULL, NULL, NULL);
if (rc < 0)
{
qDebug() << "Error calling select" << rc;
stop();
continue;
}
if (FD_ISSET(s, &rdfs))
{
int maxdlen;
// These can apparently get changed, so set before each read
iov.iov_len = sizeof(frame);
msg.msg_namelen = sizeof(addr);
msg.msg_controllen = sizeof(ctrlmsg);
msg.msg_flags = 0;
nbytes = recvmsg(s, &msg, 0);
if (nbytes < 0)
{
qDebug() << "Error calling recvmsg : " << nbytes;
stop();
continue;
}
if ((size_t)nbytes == CAN_MTU)
maxdlen = CAN_MAX_DLEN;
else if ((size_t)nbytes == CANFD_MTU)
maxdlen = CANFD_MAX_DLEN;
else
{
qDebug() << "Warning: read incomplete CAN frame : " << nbytes;
continue;
}
// TODO get timestamp from message
sendMsg(&frame, maxdlen);
}
}
}
void Monitor::stop()
{
running = 0;
}
void Monitor::sendMsg(struct canfd_frame *frame, int maxdlen)
{
canMessage msg;
char buf[200];
int pBuf = 0;
int i;
int len = (frame->len > maxdlen) ? maxdlen : frame->len;
msg.interface = 1; // TODO set in constructor at some point
msg.identifier = QString("%1:%03X")
.arg(msg.interface)
.arg(frame->can_id & CAN_SFF_MASK);
msg.time = QTime::currentTime();
pBuf += sprintf(buf + pBuf, "[%d]", frame->len);
if (frame->can_id & CAN_RTR_FLAG)
{
pBuf += sprintf(buf + pBuf, " remote request");
emit messageInBuffer(&msg);
return;
}
for (i = 0; i < len; i++)
{
pBuf += sprintf(buf + pBuf, " [%02X]", frame->data[i]);
}
msg.content = QString("%1").arg(buf);
emit messageInBuffer(&msg);
}
| Java |
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.34209
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace CC.Common.Compression.Demo.Properties
{
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
{
private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
public static Settings Default
{
get
{
return defaultInstance;
}
}
}
}
| Java |
/* Copyright (c) 2009-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* 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.
*
*/
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <linux/clk.h>
#include <linux/android_pmem.h>
#include <linux/msm_rotator.h>
#include <linux/io.h>
#include <mach/msm_rotator_imem.h>
#include <linux/ktime.h>
#include <linux/workqueue.h>
#include <linux/file.h>
#include <linux/major.h>
#include <linux/regulator/consumer.h>
#include <linux/msm_ion.h>
#include <linux/sync.h>
#include <linux/sw_sync.h>
#ifdef CONFIG_MSM_BUS_SCALING
#include <mach/msm_bus.h>
#include <mach/msm_bus_board.h>
#endif
#include <mach/msm_subsystem_map.h>
#include <mach/iommu_domains.h>
#define DRIVER_NAME "msm_rotator"
#define MSM_ROTATOR_BASE (msm_rotator_dev->io_base)
#define MSM_ROTATOR_INTR_ENABLE (MSM_ROTATOR_BASE+0x0020)
#define MSM_ROTATOR_INTR_STATUS (MSM_ROTATOR_BASE+0x0024)
#define MSM_ROTATOR_INTR_CLEAR (MSM_ROTATOR_BASE+0x0028)
#define MSM_ROTATOR_START (MSM_ROTATOR_BASE+0x0030)
#define MSM_ROTATOR_MAX_BURST_SIZE (MSM_ROTATOR_BASE+0x0050)
#define MSM_ROTATOR_HW_VERSION (MSM_ROTATOR_BASE+0x0070)
#define MSM_ROTATOR_SW_RESET (MSM_ROTATOR_BASE+0x0074)
#define MSM_ROTATOR_SRC_SIZE (MSM_ROTATOR_BASE+0x1108)
#define MSM_ROTATOR_SRCP0_ADDR (MSM_ROTATOR_BASE+0x110c)
#define MSM_ROTATOR_SRCP1_ADDR (MSM_ROTATOR_BASE+0x1110)
#define MSM_ROTATOR_SRCP2_ADDR (MSM_ROTATOR_BASE+0x1114)
#define MSM_ROTATOR_SRC_YSTRIDE1 (MSM_ROTATOR_BASE+0x111c)
#define MSM_ROTATOR_SRC_YSTRIDE2 (MSM_ROTATOR_BASE+0x1120)
#define MSM_ROTATOR_SRC_FORMAT (MSM_ROTATOR_BASE+0x1124)
#define MSM_ROTATOR_SRC_UNPACK_PATTERN1 (MSM_ROTATOR_BASE+0x1128)
#define MSM_ROTATOR_SUB_BLOCK_CFG (MSM_ROTATOR_BASE+0x1138)
#define MSM_ROTATOR_OUT_PACK_PATTERN1 (MSM_ROTATOR_BASE+0x1154)
#define MSM_ROTATOR_OUTP0_ADDR (MSM_ROTATOR_BASE+0x1168)
#define MSM_ROTATOR_OUTP1_ADDR (MSM_ROTATOR_BASE+0x116c)
#define MSM_ROTATOR_OUTP2_ADDR (MSM_ROTATOR_BASE+0x1170)
#define MSM_ROTATOR_OUT_YSTRIDE1 (MSM_ROTATOR_BASE+0x1178)
#define MSM_ROTATOR_OUT_YSTRIDE2 (MSM_ROTATOR_BASE+0x117c)
#define MSM_ROTATOR_SRC_XY (MSM_ROTATOR_BASE+0x1200)
#define MSM_ROTATOR_SRC_IMAGE_SIZE (MSM_ROTATOR_BASE+0x1208)
#define MSM_ROTATOR_MAX_ROT 0x07
#define MSM_ROTATOR_MAX_H 0x1fff
#define MSM_ROTATOR_MAX_W 0x1fff
/* from lsb to msb */
#define GET_PACK_PATTERN(a, x, y, z, bit) \
(((a)<<((bit)*3))|((x)<<((bit)*2))|((y)<<(bit))|(z))
#define CLR_G 0x0
#define CLR_B 0x1
#define CLR_R 0x2
#define CLR_ALPHA 0x3
#define CLR_Y CLR_G
#define CLR_CB CLR_B
#define CLR_CR CLR_R
#define ROTATIONS_TO_BITMASK(r) ((((r) & MDP_ROT_90) ? 1 : 0) | \
(((r) & MDP_FLIP_LR) ? 2 : 0) | \
(((r) & MDP_FLIP_UD) ? 4 : 0))
#define IMEM_NO_OWNER -1;
#define MAX_SESSIONS 16
#define INVALID_SESSION -1
#define VERSION_KEY_MASK 0xFFFFFF00
#define MAX_DOWNSCALE_RATIO 3
#define MAX_COMMIT_QUEUE 4
#define WAIT_ROT_TIMEOUT 1000
#define MAX_TIMELINE_NAME_LEN 16
#define WAIT_FENCE_FIRST_TIMEOUT MSEC_PER_SEC
#define WAIT_FENCE_FINAL_TIMEOUT (10 * MSEC_PER_SEC)
#define ROTATOR_REVISION_V0 0
#define ROTATOR_REVISION_V1 1
#define ROTATOR_REVISION_V2 2
#define ROTATOR_REVISION_NONE 0xffffffff
#define BASE_ADDR(height, y_stride) ((height % 64) * y_stride)
#define HW_BASE_ADDR(height, y_stride) (((dstp0_ystride >> 5) << 11) - \
((dst_height & 0x3f) * dstp0_ystride))
uint32_t rotator_hw_revision;
static char rot_iommu_split_domain;
/*
* rotator_hw_revision:
* 0 == 7x30
* 1 == 8x60
* 2 == 8960
*
*/
struct tile_parm {
unsigned int width; /* tile's width */
unsigned int height; /* tile's height */
unsigned int row_tile_w; /* tiles per row's width */
unsigned int row_tile_h; /* tiles per row's height */
};
struct msm_rotator_mem_planes {
unsigned int num_planes;
unsigned int plane_size[4];
unsigned int total_size;
};
#define checkoffset(offset, size, max_size) \
((size) > (max_size) || (offset) > ((max_size) - (size)))
struct msm_rotator_fd_info {
int pid;
int ref_cnt;
struct list_head list;
};
struct rot_sync_info {
u32 initialized;
struct sync_fence *acq_fen;
struct sync_fence *rel_fen;
int rel_fen_fd;
struct sw_sync_timeline *timeline;
int timeline_value;
struct mutex sync_mutex;
atomic_t queue_buf_cnt;
};
struct msm_rotator_session {
struct msm_rotator_img_info img_info;
struct msm_rotator_fd_info fd_info;
int fast_yuv_enable;
int enable_2pass;
u32 mem_hid;
};
struct msm_rotator_commit_info {
struct msm_rotator_data_info data_info;
struct msm_rotator_img_info img_info;
unsigned int format;
unsigned int in_paddr;
unsigned int out_paddr;
unsigned int in_chroma_paddr;
unsigned int out_chroma_paddr;
unsigned int in_chroma2_paddr;
unsigned int out_chroma2_paddr;
struct file *srcp0_file;
struct file *srcp1_file;
struct file *dstp0_file;
struct file *dstp1_file;
struct ion_handle *srcp0_ihdl;
struct ion_handle *srcp1_ihdl;
struct ion_handle *dstp0_ihdl;
struct ion_handle *dstp1_ihdl;
int ps0_need;
int session_index;
struct sync_fence *acq_fen;
int fast_yuv_en;
int enable_2pass;
};
struct msm_rotator_dev {
void __iomem *io_base;
int irq;
struct clk *core_clk;
struct msm_rotator_session *rot_session[MAX_SESSIONS];
struct list_head fd_list;
struct clk *pclk;
int rot_clk_state;
struct regulator *regulator;
struct delayed_work rot_clk_work;
struct clk *imem_clk;
int imem_clk_state;
struct delayed_work imem_clk_work;
struct platform_device *pdev;
struct cdev cdev;
struct device *device;
struct class *class;
dev_t dev_num;
int processing;
int last_session_idx;
struct mutex rotator_lock;
struct mutex imem_lock;
int imem_owner;
wait_queue_head_t wq;
struct ion_client *client;
#ifdef CONFIG_MSM_BUS_SCALING
uint32_t bus_client_handle;
#endif
u32 sec_mapped;
u32 mmu_clk_on;
struct rot_sync_info sync_info[MAX_SESSIONS];
/* non blocking */
struct mutex commit_mutex;
struct mutex commit_wq_mutex;
struct completion commit_comp;
u32 commit_running;
struct work_struct commit_work;
struct msm_rotator_commit_info commit_info[MAX_COMMIT_QUEUE];
atomic_t commit_q_r;
atomic_t commit_q_w;
atomic_t commit_q_cnt;
struct rot_buf_type *y_rot_buf;
struct rot_buf_type *chroma_rot_buf;
struct rot_buf_type *chroma2_rot_buf;
};
#define COMPONENT_5BITS 1
#define COMPONENT_6BITS 2
#define COMPONENT_8BITS 3
static struct msm_rotator_dev *msm_rotator_dev;
#define mrd msm_rotator_dev
static void rot_wait_for_commit_queue(u32 is_all);
enum {
CLK_EN,
CLK_DIS,
CLK_SUSPEND,
};
struct res_mmu_clk {
char *mmu_clk_name;
struct clk *mmu_clk;
};
static struct res_mmu_clk rot_mmu_clks[] = {
{"mdp_iommu_clk"}, {"rot_iommu_clk"},
{"vcodec_iommu0_clk"}, {"vcodec_iommu1_clk"},
{"smmu_iface_clk"}
};
u32 rotator_allocate_2pass_buf(struct rot_buf_type *rot_buf, int s_ndx)
{
ion_phys_addr_t addr, read_addr = 0;
size_t buffer_size;
unsigned long len;
if (!rot_buf) {
pr_err("Rot_buf NULL pointer %s %i", __func__, __LINE__);
return 0;
}
if (rot_buf->write_addr || !IS_ERR_OR_NULL(rot_buf->ihdl))
return 0;
buffer_size = roundup(1920 * 1088, SZ_4K);
if (!IS_ERR_OR_NULL(mrd->client)) {
pr_info("%s:%d ion based allocation\n",
__func__, __LINE__);
rot_buf->ihdl = ion_alloc(mrd->client, buffer_size, SZ_4K,
mrd->rot_session[s_ndx]->mem_hid,
mrd->rot_session[s_ndx]->mem_hid & ION_SECURE);
if (!IS_ERR_OR_NULL(rot_buf->ihdl)) {
if (rot_iommu_split_domain) {
if (ion_map_iommu(mrd->client, rot_buf->ihdl,
ROTATOR_SRC_DOMAIN, GEN_POOL, SZ_4K,
0, &read_addr, &len, 0, 0)) {
pr_err("ion_map_iommu() read failed\n");
return -ENOMEM;
}
if (mrd->rot_session[s_ndx]->mem_hid &
ION_SECURE) {
if (ion_phys(mrd->client, rot_buf->ihdl,
&addr, (size_t *)&len)) {
pr_err(
"%s:%d: ion_phys map failed\n",
__func__, __LINE__);
return -ENOMEM;
}
} else {
if (ion_map_iommu(mrd->client,
rot_buf->ihdl, ROTATOR_DST_DOMAIN,
GEN_POOL, SZ_4K, 0, &addr, &len,
0, 0)) {
pr_err("ion_map_iommu() failed\n");
return -ENOMEM;
}
}
} else {
if (ion_map_iommu(mrd->client, rot_buf->ihdl,
ROTATOR_SRC_DOMAIN, GEN_POOL, SZ_4K,
0, &addr, &len, 0, 0)) {
pr_err("ion_map_iommu() write failed\n");
return -ENOMEM;
}
}
} else {
pr_err("%s:%d: ion_alloc failed\n", __func__,
__LINE__);
return -ENOMEM;
}
} else {
addr = allocate_contiguous_memory_nomap(buffer_size,
mrd->rot_session[s_ndx]->mem_hid, 4);
}
if (addr) {
pr_info("allocating %d bytes at write=%x, read=%x for 2-pass\n",
buffer_size, (u32) addr, (u32) read_addr);
rot_buf->write_addr = addr;
if (read_addr)
rot_buf->read_addr = read_addr;
else
rot_buf->read_addr = rot_buf->write_addr;
return 0;
} else {
pr_err("%s cannot allocate memory for rotator 2-pass!\n",
__func__);
return -ENOMEM;
}
}
void rotator_free_2pass_buf(struct rot_buf_type *rot_buf, int s_ndx)
{
if (!rot_buf) {
pr_err("Rot_buf NULL pointer %s %i", __func__, __LINE__);
return;
}
if (!rot_buf->write_addr)
return;
if (!IS_ERR_OR_NULL(mrd->client)) {
if (!IS_ERR_OR_NULL(rot_buf->ihdl)) {
if (rot_iommu_split_domain) {
if (!(mrd->rot_session[s_ndx]->mem_hid &
ION_SECURE))
ion_unmap_iommu(mrd->client,
rot_buf->ihdl, ROTATOR_DST_DOMAIN,
GEN_POOL);
ion_unmap_iommu(mrd->client, rot_buf->ihdl,
ROTATOR_SRC_DOMAIN, GEN_POOL);
} else {
ion_unmap_iommu(mrd->client, rot_buf->ihdl,
ROTATOR_SRC_DOMAIN, GEN_POOL);
}
ion_free(mrd->client, rot_buf->ihdl);
rot_buf->ihdl = NULL;
pr_info("%s:%d Free rotator 2pass memory",
__func__, __LINE__);
}
} else {
if (rot_buf->write_addr) {
free_contiguous_memory_by_paddr(rot_buf->write_addr);
pr_debug("%s:%d Free rotator 2pass pmem\n", __func__,
__LINE__);
}
}
rot_buf->write_addr = 0;
rot_buf->read_addr = 0;
}
int msm_rotator_iommu_map_buf(int mem_id, int domain,
unsigned long *start, unsigned long *len,
struct ion_handle **pihdl, unsigned int secure)
{
if (!msm_rotator_dev->client)
return -EINVAL;
*pihdl = ion_import_dma_buf(msm_rotator_dev->client, mem_id);
if (IS_ERR_OR_NULL(*pihdl)) {
pr_err("ion_import_dma_buf() failed\n");
return PTR_ERR(*pihdl);
}
pr_debug("%s(): ion_hdl %p, ion_fd %d\n", __func__, *pihdl, mem_id);
if (rot_iommu_split_domain) {
if (secure) {
if (ion_phys(msm_rotator_dev->client,
*pihdl, start, (unsigned *)len)) {
pr_err("%s:%d: ion_phys map failed\n",
__func__, __LINE__);
return -ENOMEM;
}
} else {
if (ion_map_iommu(msm_rotator_dev->client,
*pihdl, domain, GEN_POOL,
SZ_4K, 0, start, len, 0,
ION_IOMMU_UNMAP_DELAYED)) {
pr_err("ion_map_iommu() failed\n");
return -EINVAL;
}
}
} else {
if (ion_map_iommu(msm_rotator_dev->client,
*pihdl, ROTATOR_SRC_DOMAIN, GEN_POOL,
SZ_4K, 0, start, len, 0, ION_IOMMU_UNMAP_DELAYED)) {
pr_err("ion_map_iommu() failed\n");
return -EINVAL;
}
}
pr_debug("%s(): mem_id %d, start 0x%lx, len 0x%lx\n",
__func__, mem_id, *start, *len);
return 0;
}
int msm_rotator_imem_allocate(int requestor)
{
int rc = 0;
#ifdef CONFIG_MSM_ROTATOR_USE_IMEM
switch (requestor) {
case ROTATOR_REQUEST:
if (mutex_trylock(&msm_rotator_dev->imem_lock)) {
msm_rotator_dev->imem_owner = ROTATOR_REQUEST;
rc = 1;
} else
rc = 0;
break;
case JPEG_REQUEST:
mutex_lock(&msm_rotator_dev->imem_lock);
msm_rotator_dev->imem_owner = JPEG_REQUEST;
rc = 1;
break;
default:
rc = 0;
}
#else
if (requestor == JPEG_REQUEST)
rc = 1;
#endif
if (rc == 1) {
cancel_delayed_work_sync(&msm_rotator_dev->imem_clk_work);
if (msm_rotator_dev->imem_clk_state != CLK_EN
&& msm_rotator_dev->imem_clk) {
clk_prepare_enable(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk_state = CLK_EN;
}
}
return rc;
}
EXPORT_SYMBOL(msm_rotator_imem_allocate);
void msm_rotator_imem_free(int requestor)
{
#ifdef CONFIG_MSM_ROTATOR_USE_IMEM
if (msm_rotator_dev->imem_owner == requestor) {
schedule_delayed_work(&msm_rotator_dev->imem_clk_work, HZ);
mutex_unlock(&msm_rotator_dev->imem_lock);
}
#else
if (requestor == JPEG_REQUEST)
schedule_delayed_work(&msm_rotator_dev->imem_clk_work, HZ);
#endif
}
EXPORT_SYMBOL(msm_rotator_imem_free);
static void msm_rotator_imem_clk_work_f(struct work_struct *work)
{
#ifdef CONFIG_MSM_ROTATOR_USE_IMEM
if (mutex_trylock(&msm_rotator_dev->imem_lock)) {
if (msm_rotator_dev->imem_clk_state == CLK_EN
&& msm_rotator_dev->imem_clk) {
clk_disable_unprepare(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk_state = CLK_DIS;
} else if (msm_rotator_dev->imem_clk_state == CLK_SUSPEND)
msm_rotator_dev->imem_clk_state = CLK_DIS;
mutex_unlock(&msm_rotator_dev->imem_lock);
}
#endif
}
/* enable clocks needed by rotator block */
static void enable_rot_clks(void)
{
if (msm_rotator_dev->regulator)
regulator_enable(msm_rotator_dev->regulator);
if (msm_rotator_dev->core_clk != NULL)
clk_prepare_enable(msm_rotator_dev->core_clk);
if (msm_rotator_dev->pclk != NULL)
clk_prepare_enable(msm_rotator_dev->pclk);
}
/* disable clocks needed by rotator block */
static void disable_rot_clks(void)
{
if (msm_rotator_dev->core_clk != NULL)
clk_disable_unprepare(msm_rotator_dev->core_clk);
if (msm_rotator_dev->pclk != NULL)
clk_disable_unprepare(msm_rotator_dev->pclk);
if (msm_rotator_dev->regulator)
regulator_disable(msm_rotator_dev->regulator);
}
static void msm_rotator_rot_clk_work_f(struct work_struct *work)
{
if (mutex_trylock(&msm_rotator_dev->rotator_lock)) {
if (msm_rotator_dev->rot_clk_state == CLK_EN) {
disable_rot_clks();
msm_rotator_dev->rot_clk_state = CLK_DIS;
} else if (msm_rotator_dev->rot_clk_state == CLK_SUSPEND)
msm_rotator_dev->rot_clk_state = CLK_DIS;
mutex_unlock(&msm_rotator_dev->rotator_lock);
}
}
static irqreturn_t msm_rotator_isr(int irq, void *dev_id)
{
if (msm_rotator_dev->processing) {
msm_rotator_dev->processing = 0;
wake_up(&msm_rotator_dev->wq);
} else
printk(KERN_WARNING "%s: unexpected interrupt\n", DRIVER_NAME);
return IRQ_HANDLED;
}
static void msm_rotator_signal_timeline(u32 session_index)
{
struct rot_sync_info *sync_info;
sync_info = &msm_rotator_dev->sync_info[session_index];
if ((!sync_info->timeline) || (!sync_info->initialized))
return;
mutex_lock(&sync_info->sync_mutex);
sw_sync_timeline_inc(sync_info->timeline, 1);
sync_info->timeline_value++;
mutex_unlock(&sync_info->sync_mutex);
}
static void msm_rotator_signal_timeline_done(u32 session_index)
{
struct rot_sync_info *sync_info;
sync_info = &msm_rotator_dev->sync_info[session_index];
if ((sync_info->timeline == NULL) ||
(sync_info->initialized == false))
return;
mutex_lock(&sync_info->sync_mutex);
sw_sync_timeline_inc(sync_info->timeline, 1);
sync_info->timeline_value++;
if (atomic_read(&sync_info->queue_buf_cnt) <= 0)
pr_err("%s queue_buf_cnt=%d", __func__,
atomic_read(&sync_info->queue_buf_cnt));
else
atomic_dec(&sync_info->queue_buf_cnt);
mutex_unlock(&sync_info->sync_mutex);
}
static void msm_rotator_release_acq_fence(u32 session_index)
{
struct rot_sync_info *sync_info;
sync_info = &msm_rotator_dev->sync_info[session_index];
if ((!sync_info->timeline) || (!sync_info->initialized))
return;
mutex_lock(&sync_info->sync_mutex);
sync_info->acq_fen = NULL;
mutex_unlock(&sync_info->sync_mutex);
}
static void msm_rotator_release_all_timeline(void)
{
int i;
struct rot_sync_info *sync_info;
for (i = 0; i < MAX_SESSIONS; i++) {
sync_info = &msm_rotator_dev->sync_info[i];
if (sync_info->initialized) {
msm_rotator_signal_timeline(i);
msm_rotator_release_acq_fence(i);
}
}
}
static void msm_rotator_wait_for_fence(struct sync_fence *acq_fen)
{
int ret;
if (acq_fen) {
ret = sync_fence_wait(acq_fen,
WAIT_FENCE_FIRST_TIMEOUT);
if (ret == -ETIME) {
pr_warn("%s: timeout, wait %ld more ms\n",
__func__, WAIT_FENCE_FINAL_TIMEOUT);
ret = sync_fence_wait(acq_fen,
WAIT_FENCE_FINAL_TIMEOUT);
}
if (ret < 0) {
pr_err("%s: sync_fence_wait failed! ret = %x\n",
__func__, ret);
}
sync_fence_put(acq_fen);
}
}
static int msm_rotator_buf_sync(unsigned long arg)
{
struct msm_rotator_buf_sync buf_sync;
int ret = 0;
struct sync_fence *fence = NULL;
struct rot_sync_info *sync_info;
struct sync_pt *rel_sync_pt;
struct sync_fence *rel_fence;
int rel_fen_fd;
u32 s;
if (copy_from_user(&buf_sync, (void __user *)arg, sizeof(buf_sync)))
return -EFAULT;
rot_wait_for_commit_queue(false);
for (s = 0; s < MAX_SESSIONS; s++)
if ((msm_rotator_dev->rot_session[s] != NULL) &&
(buf_sync.session_id ==
(unsigned int)msm_rotator_dev->rot_session[s]
))
break;
if (s == MAX_SESSIONS) {
pr_err("%s invalid session id %d", __func__,
buf_sync.session_id);
return -EINVAL;
}
sync_info = &msm_rotator_dev->sync_info[s];
if (sync_info->acq_fen)
pr_err("%s previous acq_fen will be overwritten", __func__);
if ((sync_info->timeline == NULL) ||
(sync_info->initialized == false))
return -EINVAL;
mutex_lock(&sync_info->sync_mutex);
if (buf_sync.acq_fen_fd >= 0)
fence = sync_fence_fdget(buf_sync.acq_fen_fd);
sync_info->acq_fen = fence;
if (sync_info->acq_fen &&
(buf_sync.flags & MDP_BUF_SYNC_FLAG_WAIT)) {
msm_rotator_wait_for_fence(sync_info->acq_fen);
sync_info->acq_fen = NULL;
}
rel_sync_pt = sw_sync_pt_create(sync_info->timeline,
sync_info->timeline_value +
atomic_read(&sync_info->queue_buf_cnt) + 1);
if (rel_sync_pt == NULL) {
pr_err("%s: cannot create sync point", __func__);
ret = -ENOMEM;
goto buf_sync_err_1;
}
/* create fence */
rel_fence = sync_fence_create("msm_rotator-fence",
rel_sync_pt);
if (rel_fence == NULL) {
sync_pt_free(rel_sync_pt);
pr_err("%s: cannot create fence", __func__);
ret = -ENOMEM;
goto buf_sync_err_1;
}
/* create fd */
rel_fen_fd = get_unused_fd_flags(0);
if (rel_fen_fd < 0) {
pr_err("%s: get_unused_fd_flags failed", __func__);
ret = -EIO;
goto buf_sync_err_2;
}
sync_fence_install(rel_fence, rel_fen_fd);
buf_sync.rel_fen_fd = rel_fen_fd;
sync_info->rel_fen = rel_fence;
sync_info->rel_fen_fd = rel_fen_fd;
ret = copy_to_user((void __user *)arg, &buf_sync, sizeof(buf_sync));
mutex_unlock(&sync_info->sync_mutex);
return ret;
buf_sync_err_2:
sync_fence_put(rel_fence);
buf_sync_err_1:
if (sync_info->acq_fen)
sync_fence_put(sync_info->acq_fen);
sync_info->acq_fen = NULL;
mutex_unlock(&sync_info->sync_mutex);
return ret;
}
static unsigned int tile_size(unsigned int src_width,
unsigned int src_height,
const struct tile_parm *tp)
{
unsigned int tile_w, tile_h;
unsigned int row_num_w, row_num_h;
tile_w = tp->width * tp->row_tile_w;
tile_h = tp->height * tp->row_tile_h;
row_num_w = (src_width + tile_w - 1) / tile_w;
row_num_h = (src_height + tile_h - 1) / tile_h;
return ((row_num_w * row_num_h * tile_w * tile_h) + 8191) & ~8191;
}
static int get_bpp(int format)
{
switch (format) {
case MDP_RGB_565:
case MDP_BGR_565:
return 2;
case MDP_XRGB_8888:
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_BGRA_8888:
case MDP_RGBX_8888:
return 4;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
case MDP_Y_CB_CR_H2V2:
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
case MDP_Y_CRCB_H2V2_TILE:
case MDP_Y_CBCR_H2V2_TILE:
return 1;
case MDP_RGB_888:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
return 3;
case MDP_YCRYCB_H2V1:
return 2;/* YCrYCb interleave */
case MDP_Y_CRCB_H2V1:
case MDP_Y_CBCR_H2V1:
return 1;
default:
return -1;
}
}
static int msm_rotator_get_plane_sizes(uint32_t format, uint32_t w, uint32_t h,
struct msm_rotator_mem_planes *p)
{
/*
* each row of samsung tile consists of two tiles in height
* and two tiles in width which means width should align to
* 64 x 2 bytes and height should align to 32 x 2 bytes.
* video decoder generate two tiles in width and one tile
* in height which ends up height align to 32 X 1 bytes.
*/
const struct tile_parm tile = {64, 32, 2, 1};
int i;
if (p == NULL)
return -EINVAL;
if ((w > MSM_ROTATOR_MAX_W) || (h > MSM_ROTATOR_MAX_H))
return -ERANGE;
memset(p, 0, sizeof(*p));
switch (format) {
case MDP_XRGB_8888:
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_BGRA_8888:
case MDP_RGBX_8888:
case MDP_RGB_888:
case MDP_RGB_565:
case MDP_BGR_565:
case MDP_YCRYCB_H2V1:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
p->num_planes = 1;
p->plane_size[0] = w * h * get_bpp(format);
break;
case MDP_Y_CRCB_H2V1:
case MDP_Y_CBCR_H2V1:
case MDP_Y_CRCB_H1V2:
case MDP_Y_CBCR_H1V2:
p->num_planes = 2;
p->plane_size[0] = w * h;
p->plane_size[1] = w * h;
break;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
p->num_planes = 2;
p->plane_size[0] = w * h;
p->plane_size[1] = w * h / 2;
break;
case MDP_Y_CRCB_H2V2_TILE:
case MDP_Y_CBCR_H2V2_TILE:
p->num_planes = 2;
p->plane_size[0] = tile_size(w, h, &tile);
p->plane_size[1] = tile_size(w, h/2, &tile);
break;
case MDP_Y_CB_CR_H2V2:
case MDP_Y_CR_CB_H2V2:
p->num_planes = 3;
p->plane_size[0] = w * h;
p->plane_size[1] = (w / 2) * (h / 2);
p->plane_size[2] = (w / 2) * (h / 2);
break;
case MDP_Y_CR_CB_GH2V2:
p->num_planes = 3;
p->plane_size[0] = ALIGN(w, 16) * h;
p->plane_size[1] = ALIGN(w / 2, 16) * (h / 2);
p->plane_size[2] = ALIGN(w / 2, 16) * (h / 2);
break;
default:
return -EINVAL;
}
for (i = 0; i < p->num_planes; i++)
p->total_size += p->plane_size[i];
return 0;
}
/* Checking invalid destination image size on FAST YUV for YUV420PP(NV12) with
* HW issue for rotation 90 + U/D filp + with/without flip operation
* (rotation 90 + U/D + L/R flip is rotation 270 degree option) and pix_rot
* block issue with tile line size is 4.
*
* Rotator structure is:
* if Fetch input image: W x H,
* Downscale: W` x H` = W/ScaleHor(2, 4 or 8) x H/ScaleVert(2, 4 or 8)
* Rotated output : W`` x H`` = (W` x H`) or (H` x W`) depends on "Rotation 90
* degree option"
*
* Pack: W`` x H``
*
* Rotator source ROI image width restriction is applied to W x H (case a,
* image resolution before downscaling)
*
* Packer source Image width/ height restriction are applied to W`` x H``
* (case c, image resolution after rotation)
*
* Supertile (64 x 8) and YUV (2 x 2) alignment restriction should be
* applied to the W x H (case a). Input image should be at least (2 x 2).
*
* "Support If packer source image height <= 256, multiple of 8", this
* restriction should be applied to the rotated image (W`` x H``)
*/
uint32_t fast_yuv_invalid_size_checker(unsigned char rot_mode,
uint32_t src_width,
uint32_t dst_width,
uint32_t src_height,
uint32_t dst_height,
uint32_t dstp0_ystride,
uint32_t is_planar420)
{
uint32_t hw_limit;
hw_limit = is_planar420 ? 512 : 256;
/* checking image constaints for missing EOT event from pix_rot block */
if ((src_width > hw_limit) && ((src_width % (hw_limit / 2)) == 8))
return -EINVAL;
if (rot_mode & MDP_ROT_90) {
if ((src_height % 128) == 8)
return -EINVAL;
/* if rotation 90 degree on fast yuv
* rotator image input width has to be multiple of 8
* rotator image input height has to be multiple of 8
*/
if (((dst_width % 8) != 0) || ((dst_height % 8) != 0))
return -EINVAL;
if ((rot_mode & MDP_FLIP_UD) ||
(rot_mode & (MDP_FLIP_UD | MDP_FLIP_LR))) {
/* image constraint checking for wrong address
* generation HW issue for Y plane checking
*/
if (((dst_height % 64) != 0) &&
((dst_height / 64) >= 4)) {
/* compare golden logic for second
* tile base address generation in row
* with actual HW implementation
*/
if (BASE_ADDR(dst_height, dstp0_ystride) !=
HW_BASE_ADDR(dst_height, dstp0_ystride))
return -EINVAL;
}
if (is_planar420) {
dst_width = dst_width / 2;
dstp0_ystride = dstp0_ystride / 2;
}
dst_height = dst_height / 2;
/* image constraint checking for wrong
* address generation HW issue. for
* U/V (P) or UV (PP) plane checking
*/
if (((dst_height % 64) != 0) && ((dst_height / 64) >=
(hw_limit / 128))) {
/* compare golden logic for
* second tile base address
* generation in row with
* actual HW implementation
*/
if (BASE_ADDR(dst_height, dstp0_ystride) !=
HW_BASE_ADDR(dst_height, dstp0_ystride))
return -EINVAL;
}
}
} else {
/* if NOT applying rotation 90 degree on fast yuv,
* rotator image input width has to be multiple of 8
* rotator image input height has to be multiple of 8
*/
if (((dst_width % 8) != 0) || ((dst_height % 8) != 0))
return -EINVAL;
}
return 0;
}
static int msm_rotator_ycxcx_h2v1(struct msm_rotator_img_info *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session,
unsigned int in_chroma_paddr,
unsigned int out_chroma_paddr)
{
int bpp;
uint32_t dst_format;
switch (info->src.format) {
case MDP_Y_CRCB_H2V1:
if (info->rotations & MDP_ROT_90)
dst_format = MDP_Y_CRCB_H1V2;
else
dst_format = info->src.format;
break;
case MDP_Y_CBCR_H2V1:
if (info->rotations & MDP_ROT_90)
dst_format = MDP_Y_CBCR_H1V2;
else
dst_format = info->src.format;
break;
default:
return -EINVAL;
}
if (info->dst.format != dst_format)
return -EINVAL;
bpp = get_bpp(info->src.format);
if (bpp < 0)
return -ENOTTY;
iowrite32(in_paddr, MSM_ROTATOR_SRCP0_ADDR);
iowrite32(in_chroma_paddr, MSM_ROTATOR_SRCP1_ADDR);
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
MSM_ROTATOR_OUTP0_ADDR);
iowrite32(out_chroma_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
MSM_ROTATOR_OUTP1_ADDR);
if (new_session) {
iowrite32(info->src.width |
info->src.width << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
if (info->rotations & MDP_ROT_90)
iowrite32(info->dst.width |
info->dst.width*2 << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
else
iowrite32(info->dst.width |
info->dst.width << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
if (info->src.format == MDP_Y_CBCR_H2V1) {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
} else {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
}
iowrite32((1 << 18) | /* chroma sampling 1=H2V1 */
(ROTATIONS_TO_BITMASK(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
MSM_ROTATOR_SUB_BLOCK_CFG);
iowrite32(0 << 29 | /* frame format 0 = linear */
(use_imem ? 0 : 1) << 22 | /* tile size */
2 << 19 | /* fetch planes 2 = pseudo */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
1 << 13 | /* unpack count 0=1 component */
(bpp-1) << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
MSM_ROTATOR_SRC_FORMAT);
}
return 0;
}
static int msm_rotator_ycxcx_h2v2(struct msm_rotator_img_info *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session,
unsigned int in_chroma_paddr,
unsigned int out_chroma_paddr,
unsigned int in_chroma2_paddr,
unsigned int out_chroma2_paddr,
int fast_yuv_en)
{
uint32_t dst_format;
int is_tile = 0;
switch (info->src.format) {
case MDP_Y_CRCB_H2V2_TILE:
is_tile = 1;
dst_format = MDP_Y_CRCB_H2V2;
break;
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
if (fast_yuv_en) {
dst_format = info->src.format;
break;
}
case MDP_Y_CRCB_H2V2:
dst_format = MDP_Y_CRCB_H2V2;
break;
case MDP_Y_CB_CR_H2V2:
if (fast_yuv_en) {
dst_format = info->src.format;
break;
}
dst_format = MDP_Y_CBCR_H2V2;
break;
case MDP_Y_CBCR_H2V2_TILE:
is_tile = 1;
case MDP_Y_CBCR_H2V2:
dst_format = MDP_Y_CBCR_H2V2;
break;
default:
return -EINVAL;
}
if (info->dst.format != dst_format)
return -EINVAL;
/* rotator expects YCbCr for planar input format */
if ((info->src.format == MDP_Y_CR_CB_H2V2 ||
info->src.format == MDP_Y_CR_CB_GH2V2) &&
rotator_hw_revision < ROTATOR_REVISION_V2)
swap(in_chroma_paddr, in_chroma2_paddr);
iowrite32(in_paddr, MSM_ROTATOR_SRCP0_ADDR);
iowrite32(in_chroma_paddr, MSM_ROTATOR_SRCP1_ADDR);
iowrite32(in_chroma2_paddr, MSM_ROTATOR_SRCP2_ADDR);
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
MSM_ROTATOR_OUTP0_ADDR);
iowrite32(out_chroma_paddr +
(((info->dst_y * info->dst.width)/2) + info->dst_x),
MSM_ROTATOR_OUTP1_ADDR);
if (out_chroma2_paddr)
iowrite32(out_chroma2_paddr +
(((info->dst_y * info->dst.width)/2) + info->dst_x),
MSM_ROTATOR_OUTP2_ADDR);
if (new_session) {
if (in_chroma2_paddr) {
if (info->src.format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(info->src.width, 16) |
ALIGN((info->src.width / 2), 16) << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
iowrite32(ALIGN((info->src.width / 2), 16),
MSM_ROTATOR_SRC_YSTRIDE2);
} else {
iowrite32(info->src.width |
(info->src.width / 2) << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
iowrite32((info->src.width / 2),
MSM_ROTATOR_SRC_YSTRIDE2);
}
} else {
iowrite32(info->src.width |
info->src.width << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
}
if (out_chroma2_paddr) {
if (info->dst.format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(info->dst.width, 16) |
ALIGN((info->dst.width / 2), 16) << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
iowrite32(ALIGN((info->dst.width / 2), 16),
MSM_ROTATOR_OUT_YSTRIDE2);
} else {
iowrite32(info->dst.width |
info->dst.width/2 << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
iowrite32(info->dst.width/2,
MSM_ROTATOR_OUT_YSTRIDE2);
}
} else {
iowrite32(info->dst.width |
info->dst.width << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
}
if (dst_format == MDP_Y_CBCR_H2V2 ||
dst_format == MDP_Y_CB_CR_H2V2) {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
} else {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
}
iowrite32((3 << 18) | /* chroma sampling 3=4:2:0 */
(ROTATIONS_TO_BITMASK(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
fast_yuv_en << 4 | /*fast YUV*/
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
MSM_ROTATOR_SUB_BLOCK_CFG);
iowrite32((is_tile ? 2 : 0) << 29 | /* frame format */
(use_imem ? 0 : 1) << 22 | /* tile size */
(in_chroma2_paddr ? 1 : 2) << 19 | /* fetch planes */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
1 << 13 | /* unpack count 0=1 component */
0 << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
MSM_ROTATOR_SRC_FORMAT);
}
return 0;
}
static int msm_rotator_ycxcx_h2v2_2pass(struct msm_rotator_img_info *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session,
unsigned int in_chroma_paddr,
unsigned int out_chroma_paddr,
unsigned int in_chroma2_paddr,
unsigned int out_chroma2_paddr,
int fast_yuv_en,
int enable_2pass,
int session_index)
{
uint32_t pass2_src_format, pass1_dst_format, dst_format;
int is_tile = 0, post_pass1_buf_is_planar = 0;
unsigned int status;
int post_pass1_ystride = info->src_rect.w >> info->downscale_ratio;
int post_pass1_height = info->src_rect.h >> info->downscale_ratio;
/* DST format = SRC format for non-tiled SRC formats
* when fast YUV is enabled. For TILED formats,
* DST format of MDP_Y_CRCB_H2V2_TILE = MDP_Y_CRCB_H2V2
* DST format of MDP_Y_CBCR_H2V2_TILE = MDP_Y_CBCR_H2V2
*/
switch (info->src.format) {
case MDP_Y_CRCB_H2V2_TILE:
is_tile = 1;
dst_format = MDP_Y_CRCB_H2V2;
pass1_dst_format = MDP_Y_CRCB_H2V2;
pass2_src_format = pass1_dst_format;
break;
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
case MDP_Y_CB_CR_H2V2:
post_pass1_buf_is_planar = 1;
case MDP_Y_CRCB_H2V2:
case MDP_Y_CBCR_H2V2:
dst_format = info->src.format;
pass1_dst_format = info->src.format;
pass2_src_format = pass1_dst_format;
break;
case MDP_Y_CBCR_H2V2_TILE:
is_tile = 1;
dst_format = MDP_Y_CBCR_H2V2;
pass1_dst_format = info->src.format;
pass2_src_format = pass1_dst_format;
break;
default:
return -EINVAL;
}
if (info->dst.format != dst_format)
return -EINVAL;
/* Beginning of Pass-1 */
/* rotator expects YCbCr for planar input format */
if ((info->src.format == MDP_Y_CR_CB_H2V2 ||
info->src.format == MDP_Y_CR_CB_GH2V2) &&
rotator_hw_revision < ROTATOR_REVISION_V2)
swap(in_chroma_paddr, in_chroma2_paddr);
iowrite32(in_paddr, MSM_ROTATOR_SRCP0_ADDR);
iowrite32(in_chroma_paddr, MSM_ROTATOR_SRCP1_ADDR);
iowrite32(in_chroma2_paddr, MSM_ROTATOR_SRCP2_ADDR);
if (new_session) {
if (in_chroma2_paddr) {
if (info->src.format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(info->src.width, 16) |
ALIGN((info->src.width / 2), 16) << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
iowrite32(ALIGN((info->src.width / 2), 16),
MSM_ROTATOR_SRC_YSTRIDE2);
} else {
iowrite32(info->src.width |
(info->src.width / 2) << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
iowrite32((info->src.width / 2),
MSM_ROTATOR_SRC_YSTRIDE2);
}
} else {
iowrite32(info->src.width |
info->src.width << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
}
}
pr_debug("src_rect.w=%i src_rect.h=%i src_rect.x=%i src_rect.y=%i",
info->src_rect.w, info->src_rect.h, info->src_rect.x,
info->src_rect.y);
pr_debug("src.width=%i src.height=%i src_format=%i",
info->src.width, info->src.height, info->src.format);
pr_debug("dst_width=%i dst_height=%i dst.x=%i dst.y=%i",
info->dst.width, info->dst.height, info->dst_x, info->dst_y);
pr_debug("post_pass1_ystride=%i post_pass1_height=%i downscale=%i",
post_pass1_ystride, post_pass1_height, info->downscale_ratio);
rotator_allocate_2pass_buf(mrd->y_rot_buf, session_index);
rotator_allocate_2pass_buf(mrd->chroma_rot_buf, session_index);
if (post_pass1_buf_is_planar)
rotator_allocate_2pass_buf(mrd->chroma2_rot_buf, session_index);
iowrite32(mrd->y_rot_buf->write_addr, MSM_ROTATOR_OUTP0_ADDR);
iowrite32(mrd->chroma_rot_buf->write_addr, MSM_ROTATOR_OUTP1_ADDR);
if (post_pass1_buf_is_planar)
iowrite32(mrd->chroma2_rot_buf->write_addr,
MSM_ROTATOR_OUTP2_ADDR);
if (post_pass1_buf_is_planar) {
if (pass1_dst_format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(post_pass1_ystride, 16) |
ALIGN((post_pass1_ystride / 2), 16) << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
iowrite32(ALIGN((post_pass1_ystride / 2), 16),
MSM_ROTATOR_OUT_YSTRIDE2);
} else {
iowrite32(post_pass1_ystride |
post_pass1_ystride / 2 << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
iowrite32(post_pass1_ystride / 2,
MSM_ROTATOR_OUT_YSTRIDE2);
}
} else {
iowrite32(post_pass1_ystride |
post_pass1_ystride << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
}
if (pass1_dst_format == MDP_Y_CBCR_H2V2 ||
pass1_dst_format == MDP_Y_CB_CR_H2V2) {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
} else {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
}
iowrite32((3 << 18) | /* chroma sampling 3=4:2:0 */
0 << 9 | /* Pass-1 No Rotation */
1 << 8 | /* ROT_EN */
fast_yuv_en << 4 | /*fast YUV*/
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
MSM_ROTATOR_SUB_BLOCK_CFG);
iowrite32((is_tile ? 2 : 0) << 29 | /* frame format */
(use_imem ? 0 : 1) << 22 | /* tile size */
(in_chroma2_paddr ? 1 : 2) << 19 | /* fetch planes */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
1 << 13 | /* unpack count 0=1 component */
0 << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
MSM_ROTATOR_SRC_FORMAT);
iowrite32(3, MSM_ROTATOR_INTR_ENABLE);
msm_rotator_dev->processing = 1;
iowrite32(0x1, MSM_ROTATOR_START);
/* End of Pass-1 */
wait_event(msm_rotator_dev->wq,
(msm_rotator_dev->processing == 0));
/* Beginning of Pass-2 */
status = (unsigned char)ioread32(MSM_ROTATOR_INTR_STATUS);
if ((status & 0x03) != 0x01) {
pr_err("%s(): AXI Bus Error, issuing SW_RESET\n",
__func__);
iowrite32(0x1, MSM_ROTATOR_SW_RESET);
}
iowrite32(0, MSM_ROTATOR_INTR_ENABLE);
iowrite32(3, MSM_ROTATOR_INTR_CLEAR);
if (use_imem)
iowrite32(0x42, MSM_ROTATOR_MAX_BURST_SIZE);
iowrite32(((post_pass1_height & 0x1fff)
<< 16) |
(post_pass1_ystride & 0x1fff),
MSM_ROTATOR_SRC_SIZE);
iowrite32(0 << 16 | 0,
MSM_ROTATOR_SRC_XY);
iowrite32(((post_pass1_height & 0x1fff)
<< 16) |
(post_pass1_ystride & 0x1fff),
MSM_ROTATOR_SRC_IMAGE_SIZE);
/* rotator expects YCbCr for planar input format */
if ((pass2_src_format == MDP_Y_CR_CB_H2V2 ||
pass2_src_format == MDP_Y_CR_CB_GH2V2) &&
rotator_hw_revision < ROTATOR_REVISION_V2)
swap(mrd->chroma_rot_buf->read_addr,
mrd->chroma2_rot_buf->read_addr);
iowrite32(mrd->y_rot_buf->read_addr, MSM_ROTATOR_SRCP0_ADDR);
iowrite32(mrd->chroma_rot_buf->read_addr,
MSM_ROTATOR_SRCP1_ADDR);
if (mrd->chroma2_rot_buf->read_addr)
iowrite32(mrd->chroma2_rot_buf->read_addr,
MSM_ROTATOR_SRCP2_ADDR);
if (post_pass1_buf_is_planar) {
if (pass2_src_format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(post_pass1_ystride, 16) |
ALIGN((post_pass1_ystride / 2), 16) << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
iowrite32(ALIGN((post_pass1_ystride / 2), 16),
MSM_ROTATOR_SRC_YSTRIDE2);
} else {
iowrite32(post_pass1_ystride |
(post_pass1_ystride / 2) << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
iowrite32((post_pass1_ystride / 2),
MSM_ROTATOR_SRC_YSTRIDE2);
}
} else {
iowrite32(post_pass1_ystride |
post_pass1_ystride << 16,
MSM_ROTATOR_SRC_YSTRIDE1);
}
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
MSM_ROTATOR_OUTP0_ADDR);
iowrite32(out_chroma_paddr +
(((info->dst_y * info->dst.width)/2) + info->dst_x),
MSM_ROTATOR_OUTP1_ADDR);
if (out_chroma2_paddr)
iowrite32(out_chroma2_paddr +
(((info->dst_y * info->dst.width)/2) + info->dst_x),
MSM_ROTATOR_OUTP2_ADDR);
if (new_session) {
if (out_chroma2_paddr) {
if (info->dst.format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(info->dst.width, 16) |
ALIGN((info->dst.width / 2), 16) << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
iowrite32(ALIGN((info->dst.width / 2), 16),
MSM_ROTATOR_OUT_YSTRIDE2);
} else {
iowrite32(info->dst.width |
info->dst.width/2 << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
iowrite32(info->dst.width/2,
MSM_ROTATOR_OUT_YSTRIDE2);
}
} else {
iowrite32(info->dst.width |
info->dst.width << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
}
if (dst_format == MDP_Y_CBCR_H2V2 ||
dst_format == MDP_Y_CB_CR_H2V2) {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
} else {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
}
iowrite32((3 << 18) | /* chroma sampling 3=4:2:0 */
(ROTATIONS_TO_BITMASK(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
fast_yuv_en << 4 | /*fast YUV*/
0 << 2 | /* No downscale in Pass-2 */
0, /* No downscale in Pass-2 */
MSM_ROTATOR_SUB_BLOCK_CFG);
iowrite32(0 << 29 |
/* Output of Pass-1 will always be non-tiled */
(use_imem ? 0 : 1) << 22 | /* tile size */
(in_chroma2_paddr ? 1 : 2) << 19 | /* fetch planes */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
1 << 13 | /* unpack count 0=1 component */
0 << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
MSM_ROTATOR_SRC_FORMAT);
}
return 0;
}
static int msm_rotator_ycrycb(struct msm_rotator_img_info *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session,
unsigned int out_chroma_paddr)
{
int bpp;
uint32_t dst_format;
if (info->src.format == MDP_YCRYCB_H2V1) {
if (info->rotations & MDP_ROT_90)
dst_format = MDP_Y_CRCB_H1V2;
else
dst_format = MDP_Y_CRCB_H2V1;
} else
return -EINVAL;
if (info->dst.format != dst_format)
return -EINVAL;
bpp = get_bpp(info->src.format);
if (bpp < 0)
return -ENOTTY;
iowrite32(in_paddr, MSM_ROTATOR_SRCP0_ADDR);
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
MSM_ROTATOR_OUTP0_ADDR);
iowrite32(out_chroma_paddr +
((info->dst_y * info->dst.width)/2 + info->dst_x),
MSM_ROTATOR_OUTP1_ADDR);
if (new_session) {
iowrite32(info->src.width * bpp,
MSM_ROTATOR_SRC_YSTRIDE1);
if (info->rotations & MDP_ROT_90)
iowrite32(info->dst.width |
(info->dst.width*2) << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
else
iowrite32(info->dst.width |
(info->dst.width) << 16,
MSM_ROTATOR_OUT_YSTRIDE1);
iowrite32(GET_PACK_PATTERN(CLR_Y, CLR_CR, CLR_Y, CLR_CB, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
iowrite32((1 << 18) | /* chroma sampling 1=H2V1 */
(ROTATIONS_TO_BITMASK(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
MSM_ROTATOR_SUB_BLOCK_CFG);
iowrite32(0 << 29 | /* frame format 0 = linear */
(use_imem ? 0 : 1) << 22 | /* tile size */
0 << 19 | /* fetch planes 0=interleaved */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
3 << 13 | /* unpack count 0=1 component */
(bpp-1) << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
MSM_ROTATOR_SRC_FORMAT);
}
return 0;
}
static int msm_rotator_rgb_types(struct msm_rotator_img_info *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session)
{
int bpp, abits, rbits, gbits, bbits;
if (info->src.format != info->dst.format)
return -EINVAL;
bpp = get_bpp(info->src.format);
if (bpp < 0)
return -ENOTTY;
iowrite32(in_paddr, MSM_ROTATOR_SRCP0_ADDR);
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x) * bpp,
MSM_ROTATOR_OUTP0_ADDR);
if (new_session) {
iowrite32(info->src.width * bpp, MSM_ROTATOR_SRC_YSTRIDE1);
iowrite32(info->dst.width * bpp, MSM_ROTATOR_OUT_YSTRIDE1);
iowrite32((0 << 18) | /* chroma sampling 0=rgb */
(ROTATIONS_TO_BITMASK(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
MSM_ROTATOR_SUB_BLOCK_CFG);
switch (info->src.format) {
case MDP_RGB_565:
iowrite32(GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
abits = 0;
rbits = COMPONENT_5BITS;
gbits = COMPONENT_6BITS;
bbits = COMPONENT_5BITS;
break;
case MDP_BGR_565:
iowrite32(GET_PACK_PATTERN(0, CLR_B, CLR_G, CLR_R, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, CLR_B, CLR_G, CLR_R, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
abits = 0;
rbits = COMPONENT_5BITS;
gbits = COMPONENT_6BITS;
bbits = COMPONENT_5BITS;
break;
case MDP_RGB_888:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
iowrite32(GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
abits = 0;
rbits = COMPONENT_8BITS;
gbits = COMPONENT_8BITS;
bbits = COMPONENT_8BITS;
break;
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_XRGB_8888:
case MDP_RGBX_8888:
iowrite32(GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G,
CLR_B, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G,
CLR_B, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
abits = COMPONENT_8BITS;
rbits = COMPONENT_8BITS;
gbits = COMPONENT_8BITS;
bbits = COMPONENT_8BITS;
break;
case MDP_BGRA_8888:
iowrite32(GET_PACK_PATTERN(CLR_ALPHA, CLR_B, CLR_G,
CLR_R, 8),
MSM_ROTATOR_SRC_UNPACK_PATTERN1);
iowrite32(GET_PACK_PATTERN(CLR_ALPHA, CLR_B, CLR_G,
CLR_R, 8),
MSM_ROTATOR_OUT_PACK_PATTERN1);
abits = COMPONENT_8BITS;
rbits = COMPONENT_8BITS;
gbits = COMPONENT_8BITS;
bbits = COMPONENT_8BITS;
break;
default:
return -EINVAL;
}
iowrite32(0 << 29 | /* frame format 0 = linear */
(use_imem ? 0 : 1) << 22 | /* tile size */
0 << 19 | /* fetch planes 0=interleaved */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
(abits ? 3 : 2) << 13 | /* unpack count 0=1 comp */
(bpp-1) << 9 | /* src Bpp 0=1 byte ... */
(abits ? 1 : 0) << 8 | /* has alpha */
abits << 6 | /* alpha bits 3=8bits */
rbits << 4 | /* R/Cr bits 1=5 2=6 3=8 */
bbits << 2 | /* B/Cb bits 1=5 2=6 3=8 */
gbits << 0, /* G/Y bits 1=5 2=6 3=8 */
MSM_ROTATOR_SRC_FORMAT);
}
return 0;
}
static int get_img(struct msmfb_data *fbd, int domain,
unsigned long *start, unsigned long *len, struct file **p_file,
int *p_need, struct ion_handle **p_ihdl, unsigned int secure)
{
int ret = 0;
#ifdef CONFIG_FB
struct file *file = NULL;
int put_needed, fb_num;
#endif
#ifdef CONFIG_ANDROID_PMEM
unsigned long vstart;
#endif
*p_need = 0;
#ifdef CONFIG_FB
if (fbd->flags & MDP_MEMORY_ID_TYPE_FB) {
file = fget_light(fbd->memory_id, &put_needed);
if (file == NULL) {
pr_err("fget_light returned NULL\n");
return -EINVAL;
}
if (MAJOR(file->f_dentry->d_inode->i_rdev) == FB_MAJOR) {
fb_num = MINOR(file->f_dentry->d_inode->i_rdev);
if (get_fb_phys_info(start, len, fb_num,
ROTATOR_SUBSYSTEM_ID)) {
pr_err("get_fb_phys_info() failed\n");
ret = -1;
} else {
*p_file = file;
*p_need = put_needed;
}
} else {
pr_err("invalid FB_MAJOR failed\n");
ret = -1;
}
if (ret)
fput_light(file, put_needed);
return ret;
}
#endif
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
return msm_rotator_iommu_map_buf(fbd->memory_id, domain, start,
len, p_ihdl, secure);
#endif
#ifdef CONFIG_ANDROID_PMEM
if (!get_pmem_file(fbd->memory_id, start, &vstart, len, p_file))
return 0;
else
return -ENOMEM;
#endif
}
static void put_img(struct file *p_file, struct ion_handle *p_ihdl,
int domain, unsigned int secure)
{
#ifdef CONFIG_ANDROID_PMEM
if (p_file != NULL)
put_pmem_file(p_file);
#endif
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
if (!IS_ERR_OR_NULL(p_ihdl)) {
pr_debug("%s(): p_ihdl %p\n", __func__, p_ihdl);
if (rot_iommu_split_domain) {
if (!secure)
ion_unmap_iommu(msm_rotator_dev->client,
p_ihdl, domain, GEN_POOL);
} else {
ion_unmap_iommu(msm_rotator_dev->client,
p_ihdl, ROTATOR_SRC_DOMAIN, GEN_POOL);
}
ion_free(msm_rotator_dev->client, p_ihdl);
}
#endif
}
static int msm_rotator_rotate_prepare(
struct msm_rotator_data_info *data_info,
struct msm_rotator_commit_info *commit_info)
{
unsigned int format;
struct msm_rotator_data_info info;
unsigned int in_paddr, out_paddr;
unsigned long src_len, dst_len;
int rc = 0, s;
struct file *srcp0_file = NULL, *dstp0_file = NULL;
struct file *srcp1_file = NULL, *dstp1_file = NULL;
struct ion_handle *srcp0_ihdl = NULL, *dstp0_ihdl = NULL;
struct ion_handle *srcp1_ihdl = NULL, *dstp1_ihdl = NULL;
int ps0_need, p_need;
unsigned int in_chroma_paddr = 0, out_chroma_paddr = 0;
unsigned int in_chroma2_paddr = 0, out_chroma2_paddr = 0;
struct msm_rotator_img_info *img_info;
struct msm_rotator_mem_planes src_planes, dst_planes;
mutex_lock(&msm_rotator_dev->rotator_lock);
info = *data_info;
for (s = 0; s < MAX_SESSIONS; s++)
if ((msm_rotator_dev->rot_session[s] != NULL) &&
(info.session_id ==
(unsigned int)msm_rotator_dev->rot_session[s]
))
break;
if (s == MAX_SESSIONS) {
pr_err("%s() : Attempt to use invalid session_id %d\n",
__func__, s);
rc = -EINVAL;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
img_info = &(msm_rotator_dev->rot_session[s]->img_info);
if (img_info->enable == 0) {
dev_dbg(msm_rotator_dev->device,
"%s() : Session_id %d not enabled\n", __func__, s);
rc = -EINVAL;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
if (msm_rotator_get_plane_sizes(img_info->src.format,
img_info->src.width,
img_info->src.height,
&src_planes)) {
pr_err("%s: invalid src format\n", __func__);
rc = -EINVAL;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
if (msm_rotator_get_plane_sizes(img_info->dst.format,
img_info->dst.width,
img_info->dst.height,
&dst_planes)) {
pr_err("%s: invalid dst format\n", __func__);
rc = -EINVAL;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
rc = get_img(&info.src, ROTATOR_SRC_DOMAIN, (unsigned long *)&in_paddr,
(unsigned long *)&src_len, &srcp0_file, &ps0_need,
&srcp0_ihdl, 0);
if (rc) {
pr_err("%s: in get_img() failed id=0x%08x\n",
DRIVER_NAME, info.src.memory_id);
goto rotate_prepare_error;
}
rc = get_img(&info.dst, ROTATOR_DST_DOMAIN, (unsigned long *)&out_paddr,
(unsigned long *)&dst_len, &dstp0_file, &p_need,
&dstp0_ihdl, img_info->secure);
if (rc) {
pr_err("%s: out get_img() failed id=0x%08x\n",
DRIVER_NAME, info.dst.memory_id);
goto rotate_prepare_error;
}
format = img_info->src.format;
if (((info.version_key & VERSION_KEY_MASK) == 0xA5B4C300) &&
((info.version_key & ~VERSION_KEY_MASK) > 0) &&
(src_planes.num_planes == 2)) {
if (checkoffset(info.src.offset,
src_planes.plane_size[0],
src_len)) {
pr_err("%s: invalid src buffer (len=%lu offset=%x)\n",
__func__, src_len, info.src.offset);
rc = -ERANGE;
goto rotate_prepare_error;
}
if (checkoffset(info.dst.offset,
dst_planes.plane_size[0],
dst_len)) {
pr_err("%s: invalid dst buffer (len=%lu offset=%x)\n",
__func__, dst_len, info.dst.offset);
rc = -ERANGE;
goto rotate_prepare_error;
}
rc = get_img(&info.src_chroma, ROTATOR_SRC_DOMAIN,
(unsigned long *)&in_chroma_paddr,
(unsigned long *)&src_len, &srcp1_file, &p_need,
&srcp1_ihdl, 0);
if (rc) {
pr_err("%s: in chroma get_img() failed id=0x%08x\n",
DRIVER_NAME, info.src_chroma.memory_id);
goto rotate_prepare_error;
}
rc = get_img(&info.dst_chroma, ROTATOR_DST_DOMAIN,
(unsigned long *)&out_chroma_paddr,
(unsigned long *)&dst_len, &dstp1_file, &p_need,
&dstp1_ihdl, img_info->secure);
if (rc) {
pr_err("%s: out chroma get_img() failed id=0x%08x\n",
DRIVER_NAME, info.dst_chroma.memory_id);
goto rotate_prepare_error;
}
if (checkoffset(info.src_chroma.offset,
src_planes.plane_size[1],
src_len)) {
pr_err("%s: invalid chr src buf len=%lu offset=%x\n",
__func__, src_len, info.src_chroma.offset);
rc = -ERANGE;
goto rotate_prepare_error;
}
if (checkoffset(info.dst_chroma.offset,
src_planes.plane_size[1],
dst_len)) {
pr_err("%s: invalid chr dst buf len=%lu offset=%x\n",
__func__, dst_len, info.dst_chroma.offset);
rc = -ERANGE;
goto rotate_prepare_error;
}
in_chroma_paddr += info.src_chroma.offset;
out_chroma_paddr += info.dst_chroma.offset;
} else {
if (checkoffset(info.src.offset,
src_planes.total_size,
src_len)) {
pr_err("%s: invalid src buffer (len=%lu offset=%x)\n",
__func__, src_len, info.src.offset);
rc = -ERANGE;
goto rotate_prepare_error;
}
if (checkoffset(info.dst.offset,
dst_planes.total_size,
dst_len)) {
pr_err("%s: invalid dst buffer (len=%lu offset=%x)\n",
__func__, dst_len, info.dst.offset);
rc = -ERANGE;
goto rotate_prepare_error;
}
}
in_paddr += info.src.offset;
out_paddr += info.dst.offset;
if (!in_chroma_paddr && src_planes.num_planes >= 2)
in_chroma_paddr = in_paddr + src_planes.plane_size[0];
if (!out_chroma_paddr && dst_planes.num_planes >= 2)
out_chroma_paddr = out_paddr + dst_planes.plane_size[0];
if (src_planes.num_planes >= 3)
in_chroma2_paddr = in_chroma_paddr + src_planes.plane_size[1];
if (dst_planes.num_planes >= 3)
out_chroma2_paddr = out_chroma_paddr + dst_planes.plane_size[1];
commit_info->data_info = info;
commit_info->img_info = *img_info;
commit_info->format = format;
commit_info->in_paddr = in_paddr;
commit_info->out_paddr = out_paddr;
commit_info->in_chroma_paddr = in_chroma_paddr;
commit_info->out_chroma_paddr = out_chroma_paddr;
commit_info->in_chroma2_paddr = in_chroma2_paddr;
commit_info->out_chroma2_paddr = out_chroma2_paddr;
commit_info->srcp0_file = srcp0_file;
commit_info->srcp1_file = srcp1_file;
commit_info->srcp0_ihdl = srcp0_ihdl;
commit_info->srcp1_ihdl = srcp1_ihdl;
commit_info->dstp0_file = dstp0_file;
commit_info->dstp0_ihdl = dstp0_ihdl;
commit_info->dstp1_file = dstp1_file;
commit_info->dstp1_ihdl = dstp1_ihdl;
commit_info->ps0_need = ps0_need;
commit_info->session_index = s;
commit_info->acq_fen = msm_rotator_dev->sync_info[s].acq_fen;
commit_info->fast_yuv_en = mrd->rot_session[s]->fast_yuv_enable;
commit_info->enable_2pass = mrd->rot_session[s]->enable_2pass;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
rotate_prepare_error:
put_img(dstp1_file, dstp1_ihdl, ROTATOR_DST_DOMAIN,
msm_rotator_dev->rot_session[s]->img_info.secure);
put_img(srcp1_file, srcp1_ihdl, ROTATOR_SRC_DOMAIN, 0);
put_img(dstp0_file, dstp0_ihdl, ROTATOR_DST_DOMAIN,
msm_rotator_dev->rot_session[s]->img_info.secure);
/* only source may use frame buffer */
if (info.src.flags & MDP_MEMORY_ID_TYPE_FB)
fput_light(srcp0_file, ps0_need);
else
put_img(srcp0_file, srcp0_ihdl, ROTATOR_SRC_DOMAIN, 0);
dev_dbg(msm_rotator_dev->device, "%s() returning rc = %d\n",
__func__, rc);
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
static int msm_rotator_do_rotate_sub(
struct msm_rotator_commit_info *commit_info)
{
unsigned int status, format;
struct msm_rotator_data_info info;
unsigned int in_paddr, out_paddr;
int use_imem = 0, rc = 0;
struct file *srcp0_file, *dstp0_file;
struct file *srcp1_file, *dstp1_file;
struct ion_handle *srcp0_ihdl, *dstp0_ihdl;
struct ion_handle *srcp1_ihdl, *dstp1_ihdl;
int s, ps0_need;
unsigned int in_chroma_paddr, out_chroma_paddr;
unsigned int in_chroma2_paddr, out_chroma2_paddr;
struct msm_rotator_img_info *img_info;
mutex_lock(&msm_rotator_dev->rotator_lock);
info = commit_info->data_info;
img_info = &commit_info->img_info;
format = commit_info->format;
in_paddr = commit_info->in_paddr;
out_paddr = commit_info->out_paddr;
in_chroma_paddr = commit_info->in_chroma_paddr;
out_chroma_paddr = commit_info->out_chroma_paddr;
in_chroma2_paddr = commit_info->in_chroma2_paddr;
out_chroma2_paddr = commit_info->out_chroma2_paddr;
srcp0_file = commit_info->srcp0_file;
srcp1_file = commit_info->srcp1_file;
srcp0_ihdl = commit_info->srcp0_ihdl;
srcp1_ihdl = commit_info->srcp1_ihdl;
dstp0_file = commit_info->dstp0_file;
dstp0_ihdl = commit_info->dstp0_ihdl;
dstp1_file = commit_info->dstp1_file;
dstp1_ihdl = commit_info->dstp1_ihdl;
ps0_need = commit_info->ps0_need;
s = commit_info->session_index;
msm_rotator_wait_for_fence(commit_info->acq_fen);
commit_info->acq_fen = NULL;
cancel_delayed_work_sync(&msm_rotator_dev->rot_clk_work);
if (msm_rotator_dev->rot_clk_state != CLK_EN) {
enable_rot_clks();
msm_rotator_dev->rot_clk_state = CLK_EN;
}
enable_irq(msm_rotator_dev->irq);
#ifdef CONFIG_MSM_ROTATOR_USE_IMEM
use_imem = msm_rotator_imem_allocate(ROTATOR_REQUEST);
#else
use_imem = 0;
#endif
/*
* workaround for a hardware bug. rotator hardware hangs when we
* use write burst beat size 16 on 128X128 tile fetch mode. As a
* temporary fix use 0x42 for BURST_SIZE when imem used.
*/
if (use_imem)
iowrite32(0x42, MSM_ROTATOR_MAX_BURST_SIZE);
iowrite32(((img_info->src_rect.h & 0x1fff)
<< 16) |
(img_info->src_rect.w & 0x1fff),
MSM_ROTATOR_SRC_SIZE);
iowrite32(((img_info->src_rect.y & 0x1fff)
<< 16) |
(img_info->src_rect.x & 0x1fff),
MSM_ROTATOR_SRC_XY);
iowrite32(((img_info->src.height & 0x1fff)
<< 16) |
(img_info->src.width & 0x1fff),
MSM_ROTATOR_SRC_IMAGE_SIZE);
switch (format) {
case MDP_RGB_565:
case MDP_BGR_565:
case MDP_RGB_888:
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_XRGB_8888:
case MDP_BGRA_8888:
case MDP_RGBX_8888:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
rc = msm_rotator_rgb_types(img_info,
in_paddr, out_paddr,
use_imem,
msm_rotator_dev->last_session_idx
!= s);
break;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
case MDP_Y_CB_CR_H2V2:
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
case MDP_Y_CRCB_H2V2_TILE:
case MDP_Y_CBCR_H2V2_TILE:
if (!commit_info->enable_2pass)
rc = msm_rotator_ycxcx_h2v2(img_info,
in_paddr, out_paddr, use_imem,
msm_rotator_dev->last_session_idx
!= s,
in_chroma_paddr,
out_chroma_paddr,
in_chroma2_paddr,
out_chroma2_paddr,
commit_info->fast_yuv_en);
else
rc = msm_rotator_ycxcx_h2v2_2pass(img_info,
in_paddr, out_paddr, use_imem,
msm_rotator_dev->last_session_idx
!= s,
in_chroma_paddr,
out_chroma_paddr,
in_chroma2_paddr,
out_chroma2_paddr,
commit_info->fast_yuv_en,
commit_info->enable_2pass,
s);
break;
case MDP_Y_CBCR_H2V1:
case MDP_Y_CRCB_H2V1:
rc = msm_rotator_ycxcx_h2v1(img_info,
in_paddr, out_paddr, use_imem,
msm_rotator_dev->last_session_idx
!= s,
in_chroma_paddr,
out_chroma_paddr);
break;
case MDP_YCRYCB_H2V1:
rc = msm_rotator_ycrycb(img_info,
in_paddr, out_paddr, use_imem,
msm_rotator_dev->last_session_idx != s,
out_chroma_paddr);
break;
default:
rc = -EINVAL;
pr_err("%s(): Unsupported format %u\n", __func__, format);
goto do_rotate_exit;
}
if (rc != 0) {
msm_rotator_dev->last_session_idx = INVALID_SESSION;
pr_err("%s(): Invalid session error\n", __func__);
goto do_rotate_exit;
}
iowrite32(3, MSM_ROTATOR_INTR_ENABLE);
msm_rotator_dev->processing = 1;
iowrite32(0x1, MSM_ROTATOR_START);
wait_event(msm_rotator_dev->wq,
(msm_rotator_dev->processing == 0));
status = (unsigned char)ioread32(MSM_ROTATOR_INTR_STATUS);
if ((status & 0x03) != 0x01) {
pr_err("%s(): AXI Bus Error, issuing SW_RESET\n", __func__);
iowrite32(0x1, MSM_ROTATOR_SW_RESET);
rc = -EFAULT;
}
iowrite32(0, MSM_ROTATOR_INTR_ENABLE);
iowrite32(3, MSM_ROTATOR_INTR_CLEAR);
do_rotate_exit:
disable_irq(msm_rotator_dev->irq);
#ifdef CONFIG_MSM_ROTATOR_USE_IMEM
msm_rotator_imem_free(ROTATOR_REQUEST);
#endif
schedule_delayed_work(&msm_rotator_dev->rot_clk_work, HZ);
put_img(dstp1_file, dstp1_ihdl, ROTATOR_DST_DOMAIN,
img_info->secure);
put_img(srcp1_file, srcp1_ihdl, ROTATOR_SRC_DOMAIN, 0);
put_img(dstp0_file, dstp0_ihdl, ROTATOR_DST_DOMAIN,
img_info->secure);
/* only source may use frame buffer */
if (info.src.flags & MDP_MEMORY_ID_TYPE_FB)
fput_light(srcp0_file, ps0_need);
else
put_img(srcp0_file, srcp0_ihdl, ROTATOR_SRC_DOMAIN, 0);
msm_rotator_signal_timeline_done(s);
mutex_unlock(&msm_rotator_dev->rotator_lock);
dev_dbg(msm_rotator_dev->device, "%s() returning rc = %d\n",
__func__, rc);
return rc;
}
static void rot_wait_for_commit_queue(u32 is_all)
{
int ret = 0;
u32 loop_cnt = 0;
while (1) {
mutex_lock(&mrd->commit_mutex);
if (is_all && (atomic_read(&mrd->commit_q_cnt) == 0))
break;
if ((!is_all) &&
(atomic_read(&mrd->commit_q_cnt) < MAX_COMMIT_QUEUE))
break;
INIT_COMPLETION(mrd->commit_comp);
mutex_unlock(&mrd->commit_mutex);
ret = wait_for_completion_interruptible_timeout(
&mrd->commit_comp,
msecs_to_jiffies(WAIT_ROT_TIMEOUT));
if ((ret <= 0) ||
(atomic_read(&mrd->commit_q_cnt) >= MAX_COMMIT_QUEUE) ||
(loop_cnt > MAX_COMMIT_QUEUE)) {
pr_err("%s wait for commit queue failed ret=%d pointers:%d %d",
__func__, ret, atomic_read(&mrd->commit_q_r),
atomic_read(&mrd->commit_q_w));
mutex_lock(&mrd->commit_mutex);
ret = -ETIME;
break;
} else {
ret = 0;
}
loop_cnt++;
};
if (is_all || ret) {
atomic_set(&mrd->commit_q_r, 0);
atomic_set(&mrd->commit_q_cnt, 0);
atomic_set(&mrd->commit_q_w, 0);
}
mutex_unlock(&mrd->commit_mutex);
}
static int msm_rotator_do_rotate(unsigned long arg)
{
struct msm_rotator_data_info info;
struct rot_sync_info *sync_info;
int session_index, ret;
int commit_q_w;
if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
return -EFAULT;
rot_wait_for_commit_queue(false);
mutex_lock(&mrd->commit_mutex);
commit_q_w = atomic_read(&mrd->commit_q_w);
ret = msm_rotator_rotate_prepare(&info,
&mrd->commit_info[commit_q_w]);
if (ret) {
mutex_unlock(&mrd->commit_mutex);
return ret;
}
session_index = mrd->commit_info[commit_q_w].session_index;
sync_info = &msm_rotator_dev->sync_info[session_index];
mutex_lock(&sync_info->sync_mutex);
atomic_inc(&sync_info->queue_buf_cnt);
sync_info->acq_fen = NULL;
mutex_unlock(&sync_info->sync_mutex);
if (atomic_inc_return(&mrd->commit_q_w) >= MAX_COMMIT_QUEUE)
atomic_set(&mrd->commit_q_w, 0);
atomic_inc(&mrd->commit_q_cnt);
schedule_work(&mrd->commit_work);
mutex_unlock(&mrd->commit_mutex);
if (info.wait_for_finish)
rot_wait_for_commit_queue(true);
return 0;
}
static void rot_commit_wq_handler(struct work_struct *work)
{
mutex_lock(&mrd->commit_wq_mutex);
mutex_lock(&mrd->commit_mutex);
while (atomic_read(&mrd->commit_q_cnt) > 0) {
mrd->commit_running = true;
mutex_unlock(&mrd->commit_mutex);
msm_rotator_do_rotate_sub(
&mrd->commit_info[atomic_read(&mrd->commit_q_r)]);
mutex_lock(&mrd->commit_mutex);
if (atomic_read(&mrd->commit_q_cnt) > 0) {
atomic_dec(&mrd->commit_q_cnt);
if (atomic_inc_return(&mrd->commit_q_r) >=
MAX_COMMIT_QUEUE)
atomic_set(&mrd->commit_q_r, 0);
}
complete_all(&mrd->commit_comp);
}
mrd->commit_running = false;
if (atomic_read(&mrd->commit_q_r) != atomic_read(&mrd->commit_q_w))
pr_err("%s invalid state: r=%d w=%d cnt=%d", __func__,
atomic_read(&mrd->commit_q_r),
atomic_read(&mrd->commit_q_w),
atomic_read(&mrd->commit_q_cnt));
mutex_unlock(&mrd->commit_mutex);
mutex_unlock(&mrd->commit_wq_mutex);
}
static void msm_rotator_set_perf_level(u32 wh, u32 is_rgb)
{
u32 perf_level;
if (is_rgb)
perf_level = 1;
else if (wh <= (640 * 480))
perf_level = 2;
else if (wh <= (736 * 1280))
perf_level = 3;
else
perf_level = 4;
#ifdef CONFIG_MSM_BUS_SCALING
msm_bus_scale_client_update_request(msm_rotator_dev->bus_client_handle,
perf_level);
#endif
}
static int rot_enable_iommu_clocks(struct msm_rotator_dev *rot_dev)
{
int ret = 0, i;
if (rot_dev->mmu_clk_on)
return 0;
for (i = 0; i < ARRAY_SIZE(rot_mmu_clks); i++) {
rot_mmu_clks[i].mmu_clk = clk_get(&msm_rotator_dev->pdev->dev,
rot_mmu_clks[i].mmu_clk_name);
if (IS_ERR(rot_mmu_clks[i].mmu_clk)) {
pr_err(" %s: Get failed for clk %s", __func__,
rot_mmu_clks[i].mmu_clk_name);
ret = PTR_ERR(rot_mmu_clks[i].mmu_clk);
break;
}
ret = clk_prepare_enable(rot_mmu_clks[i].mmu_clk);
if (ret) {
clk_put(rot_mmu_clks[i].mmu_clk);
rot_mmu_clks[i].mmu_clk = NULL;
}
}
if (ret) {
for (i--; i >= 0; i--) {
clk_disable_unprepare(rot_mmu_clks[i].mmu_clk);
clk_put(rot_mmu_clks[i].mmu_clk);
rot_mmu_clks[i].mmu_clk = NULL;
}
} else {
rot_dev->mmu_clk_on = 1;
}
return ret;
}
static int rot_disable_iommu_clocks(struct msm_rotator_dev *rot_dev)
{
int i;
if (!rot_dev->mmu_clk_on)
return 0;
for (i = 0; i < ARRAY_SIZE(rot_mmu_clks); i++) {
clk_disable_unprepare(rot_mmu_clks[i].mmu_clk);
clk_put(rot_mmu_clks[i].mmu_clk);
rot_mmu_clks[i].mmu_clk = NULL;
}
rot_dev->mmu_clk_on = 0;
return 0;
}
static int map_sec_resource(struct msm_rotator_dev *rot_dev)
{
int ret = 0;
if (rot_dev->sec_mapped)
return 0;
ret = rot_enable_iommu_clocks(rot_dev);
if (ret) {
pr_err("IOMMU clock enabled failed while open");
return ret;
}
ret = msm_ion_secure_heap(ION_HEAP(ION_CP_MM_HEAP_ID));
if (ret)
pr_err("ION heap secure failed heap id %d ret %d\n",
ION_CP_MM_HEAP_ID, ret);
else
rot_dev->sec_mapped = 1;
rot_disable_iommu_clocks(rot_dev);
return ret;
}
static int unmap_sec_resource(struct msm_rotator_dev *rot_dev)
{
int ret = 0;
ret = rot_enable_iommu_clocks(rot_dev);
if (ret) {
pr_err("IOMMU clock enabled failed while close\n");
return ret;
}
msm_ion_unsecure_heap(ION_HEAP(ION_CP_MM_HEAP_ID));
rot_dev->sec_mapped = 0;
rot_disable_iommu_clocks(rot_dev);
return ret;
}
static int msm_rotator_start(unsigned long arg,
struct msm_rotator_fd_info *fd_info)
{
struct msm_rotator_img_info info;
struct msm_rotator_session *rot_session = NULL;
int rc = 0;
int s, is_rgb = 0;
int first_free_idx = INVALID_SESSION;
unsigned int dst_w, dst_h;
unsigned int is_planar420 = 0;
int fast_yuv_en = 0, enable_2pass = 0;
struct rot_sync_info *sync_info;
if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
return -EFAULT;
if ((info.rotations > MSM_ROTATOR_MAX_ROT) ||
(info.src.height > MSM_ROTATOR_MAX_H) ||
(info.src.width > MSM_ROTATOR_MAX_W) ||
(info.dst.height > MSM_ROTATOR_MAX_H) ||
(info.dst.width > MSM_ROTATOR_MAX_W) ||
(info.downscale_ratio > MAX_DOWNSCALE_RATIO)) {
pr_err("%s: Invalid parameters\n", __func__);
return -EINVAL;
}
if (info.rotations & MDP_ROT_90) {
dst_w = info.src_rect.h >> info.downscale_ratio;
dst_h = info.src_rect.w >> info.downscale_ratio;
} else {
dst_w = info.src_rect.w >> info.downscale_ratio;
dst_h = info.src_rect.h >> info.downscale_ratio;
}
if (checkoffset(info.src_rect.x, info.src_rect.w, info.src.width) ||
checkoffset(info.src_rect.y, info.src_rect.h, info.src.height) ||
checkoffset(info.dst_x, dst_w, info.dst.width) ||
checkoffset(info.dst_y, dst_h, info.dst.height)) {
pr_err("%s: Invalid src or dst rect\n", __func__);
return -ERANGE;
}
switch (info.src.format) {
case MDP_Y_CB_CR_H2V2:
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
is_planar420 = 1;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
case MDP_Y_CRCB_H2V2_TILE:
case MDP_Y_CBCR_H2V2_TILE:
if (rotator_hw_revision >= ROTATOR_REVISION_V2) {
if (info.downscale_ratio &&
(info.rotations & MDP_ROT_90)) {
fast_yuv_en = !fast_yuv_invalid_size_checker(
0,
info.src.width,
info.src_rect.w >>
info.downscale_ratio,
info.src.height,
info.src_rect.h >>
info.downscale_ratio,
info.src_rect.w >>
info.downscale_ratio,
is_planar420);
fast_yuv_en = fast_yuv_en &&
!fast_yuv_invalid_size_checker(
info.rotations,
info.src_rect.w >>
info.downscale_ratio,
dst_w,
info.src_rect.h >>
info.downscale_ratio,
dst_h,
dst_w,
is_planar420);
} else {
fast_yuv_en = !fast_yuv_invalid_size_checker(
info.rotations,
info.src.width,
dst_w,
info.src.height,
dst_h,
dst_w,
is_planar420);
}
if (fast_yuv_en && info.downscale_ratio &&
(info.rotations & MDP_ROT_90))
enable_2pass = 1;
}
break;
default:
fast_yuv_en = 0;
}
switch (info.src.format) {
case MDP_RGB_565:
case MDP_BGR_565:
case MDP_RGB_888:
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_XRGB_8888:
case MDP_RGBX_8888:
case MDP_BGRA_8888:
is_rgb = 1;
info.dst.format = info.src.format;
break;
case MDP_Y_CBCR_H2V1:
if (info.rotations & MDP_ROT_90) {
info.dst.format = MDP_Y_CBCR_H1V2;
break;
}
case MDP_Y_CRCB_H2V1:
if (info.rotations & MDP_ROT_90) {
info.dst.format = MDP_Y_CRCB_H1V2;
break;
}
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
info.dst.format = info.src.format;
break;
case MDP_YCRYCB_H2V1:
if (info.rotations & MDP_ROT_90)
info.dst.format = MDP_Y_CRCB_H1V2;
else
info.dst.format = MDP_Y_CRCB_H2V1;
break;
case MDP_Y_CB_CR_H2V2:
if (fast_yuv_en) {
info.dst.format = info.src.format;
break;
}
case MDP_Y_CBCR_H2V2_TILE:
info.dst.format = MDP_Y_CBCR_H2V2;
break;
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
if (fast_yuv_en) {
info.dst.format = info.src.format;
break;
}
case MDP_Y_CRCB_H2V2_TILE:
info.dst.format = MDP_Y_CRCB_H2V2;
break;
default:
return -EINVAL;
}
mutex_lock(&msm_rotator_dev->rotator_lock);
msm_rotator_set_perf_level((info.src.width*info.src.height), is_rgb);
for (s = 0; s < MAX_SESSIONS; s++) {
if ((msm_rotator_dev->rot_session[s] != NULL) &&
(info.session_id ==
(unsigned int)msm_rotator_dev->rot_session[s]
)) {
rot_session = msm_rotator_dev->rot_session[s];
rot_session->img_info = info;
rot_session->fd_info = *fd_info;
rot_session->fast_yuv_enable = fast_yuv_en;
rot_session->enable_2pass = enable_2pass;
if (msm_rotator_dev->last_session_idx == s)
msm_rotator_dev->last_session_idx =
INVALID_SESSION;
break;
}
if ((msm_rotator_dev->rot_session[s] == NULL) &&
(first_free_idx == INVALID_SESSION))
first_free_idx = s;
}
if ((s == MAX_SESSIONS) && (first_free_idx != INVALID_SESSION)) {
/* allocate a session id */
msm_rotator_dev->rot_session[first_free_idx] =
kzalloc(sizeof(struct msm_rotator_session),
GFP_KERNEL);
if (!msm_rotator_dev->rot_session[first_free_idx]) {
printk(KERN_ERR "%s : unable to alloc mem\n",
__func__);
rc = -ENOMEM;
goto rotator_start_exit;
}
info.session_id = (unsigned int)
msm_rotator_dev->rot_session[first_free_idx];
rot_session = msm_rotator_dev->rot_session[first_free_idx];
rot_session->img_info = info;
rot_session->fd_info = *fd_info;
rot_session->fast_yuv_enable = fast_yuv_en;
rot_session->enable_2pass = enable_2pass;
if (!IS_ERR_OR_NULL(mrd->client)) {
if (rot_session->img_info.secure) {
rot_session->mem_hid &= ~BIT(ION_IOMMU_HEAP_ID);
rot_session->mem_hid |= BIT(ION_CP_MM_HEAP_ID);
rot_session->mem_hid |= ION_SECURE;
} else {
rot_session->mem_hid &= ~BIT(ION_CP_MM_HEAP_ID);
rot_session->mem_hid &= ~ION_SECURE;
rot_session->mem_hid |= BIT(ION_IOMMU_HEAP_ID);
}
}
s = first_free_idx;
} else if (s == MAX_SESSIONS) {
dev_dbg(msm_rotator_dev->device, "%s: all sessions in use\n",
__func__);
rc = -EBUSY;
}
if (rc == 0 && copy_to_user((void __user *)arg, &info, sizeof(info)))
rc = -EFAULT;
if ((rc == 0) && (info.secure))
map_sec_resource(msm_rotator_dev);
sync_info = &msm_rotator_dev->sync_info[s];
if ((rc == 0) && (sync_info->initialized == false)) {
char timeline_name[MAX_TIMELINE_NAME_LEN];
if (sync_info->timeline == NULL) {
snprintf(timeline_name, sizeof(timeline_name),
"msm_rot_%d", first_free_idx);
sync_info->timeline =
sw_sync_timeline_create(timeline_name);
if (sync_info->timeline == NULL)
pr_err("%s: cannot create %s time line",
__func__, timeline_name);
sync_info->timeline_value = 0;
}
mutex_init(&sync_info->sync_mutex);
sync_info->initialized = true;
}
sync_info->acq_fen = NULL;
atomic_set(&sync_info->queue_buf_cnt, 0);
rotator_start_exit:
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
static int msm_rotator_finish(unsigned long arg)
{
int rc = 0;
int s;
unsigned int session_id;
if (copy_from_user(&session_id, (void __user *)arg, sizeof(s)))
return -EFAULT;
rot_wait_for_commit_queue(true);
mutex_lock(&msm_rotator_dev->rotator_lock);
for (s = 0; s < MAX_SESSIONS; s++) {
if ((msm_rotator_dev->rot_session[s] != NULL) &&
(session_id ==
(unsigned int)msm_rotator_dev->rot_session[s])) {
if (msm_rotator_dev->last_session_idx == s)
msm_rotator_dev->last_session_idx =
INVALID_SESSION;
msm_rotator_signal_timeline(s);
msm_rotator_release_acq_fence(s);
if (msm_rotator_dev->rot_session[s]->enable_2pass) {
rotator_free_2pass_buf(mrd->y_rot_buf, s);
rotator_free_2pass_buf(mrd->chroma_rot_buf, s);
rotator_free_2pass_buf(mrd->chroma2_rot_buf, s);
}
kfree(msm_rotator_dev->rot_session[s]);
msm_rotator_dev->rot_session[s] = NULL;
break;
}
}
if (s == MAX_SESSIONS)
rc = -EINVAL;
#ifdef CONFIG_MSM_BUS_SCALING
msm_bus_scale_client_update_request(msm_rotator_dev->bus_client_handle,
0);
#endif
if (msm_rotator_dev->sec_mapped)
unmap_sec_resource(msm_rotator_dev);
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
static int
msm_rotator_open(struct inode *inode, struct file *filp)
{
struct msm_rotator_fd_info *tmp, *fd_info = NULL;
int i;
if (filp->private_data)
return -EBUSY;
mutex_lock(&msm_rotator_dev->rotator_lock);
for (i = 0; i < MAX_SESSIONS; i++) {
if (msm_rotator_dev->rot_session[i] == NULL)
break;
}
if (i == MAX_SESSIONS) {
mutex_unlock(&msm_rotator_dev->rotator_lock);
return -EBUSY;
}
list_for_each_entry(tmp, &msm_rotator_dev->fd_list, list) {
if (tmp->pid == current->pid) {
fd_info = tmp;
break;
}
}
if (!fd_info) {
fd_info = kzalloc(sizeof(*fd_info), GFP_KERNEL);
if (!fd_info) {
mutex_unlock(&msm_rotator_dev->rotator_lock);
pr_err("%s: insufficient memory to alloc resources\n",
__func__);
return -ENOMEM;
}
list_add(&fd_info->list, &msm_rotator_dev->fd_list);
fd_info->pid = current->pid;
}
fd_info->ref_cnt++;
mutex_unlock(&msm_rotator_dev->rotator_lock);
filp->private_data = fd_info;
return 0;
}
static int
msm_rotator_close(struct inode *inode, struct file *filp)
{
struct msm_rotator_fd_info *fd_info;
int s;
fd_info = (struct msm_rotator_fd_info *)filp->private_data;
mutex_lock(&msm_rotator_dev->rotator_lock);
if (--fd_info->ref_cnt > 0) {
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
}
for (s = 0; s < MAX_SESSIONS; s++) {
if (msm_rotator_dev->rot_session[s] != NULL &&
&(msm_rotator_dev->rot_session[s]->fd_info) == fd_info) {
pr_debug("%s: freeing rotator session %p (pid %d)\n",
__func__, msm_rotator_dev->rot_session[s],
fd_info->pid);
rot_wait_for_commit_queue(true);
msm_rotator_signal_timeline(s);
kfree(msm_rotator_dev->rot_session[s]);
msm_rotator_dev->rot_session[s] = NULL;
if (msm_rotator_dev->last_session_idx == s)
msm_rotator_dev->last_session_idx =
INVALID_SESSION;
}
}
list_del(&fd_info->list);
kfree(fd_info);
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
}
static long msm_rotator_ioctl(struct file *file, unsigned cmd,
unsigned long arg)
{
struct msm_rotator_fd_info *fd_info;
if (_IOC_TYPE(cmd) != MSM_ROTATOR_IOCTL_MAGIC)
return -ENOTTY;
fd_info = (struct msm_rotator_fd_info *)file->private_data;
switch (cmd) {
case MSM_ROTATOR_IOCTL_START:
return msm_rotator_start(arg, fd_info);
case MSM_ROTATOR_IOCTL_ROTATE:
return msm_rotator_do_rotate(arg);
case MSM_ROTATOR_IOCTL_FINISH:
return msm_rotator_finish(arg);
case MSM_ROTATOR_IOCTL_BUFFER_SYNC:
return msm_rotator_buf_sync(arg);
default:
dev_dbg(msm_rotator_dev->device,
"unexpected IOCTL %d\n", cmd);
return -ENOTTY;
}
}
static const struct file_operations msm_rotator_fops = {
.owner = THIS_MODULE,
.open = msm_rotator_open,
.release = msm_rotator_close,
.unlocked_ioctl = msm_rotator_ioctl,
};
static int __devinit msm_rotator_probe(struct platform_device *pdev)
{
int rc = 0;
struct resource *res;
struct msm_rotator_platform_data *pdata = NULL;
int i, number_of_clks;
uint32_t ver;
msm_rotator_dev = kzalloc(sizeof(struct msm_rotator_dev), GFP_KERNEL);
if (!msm_rotator_dev) {
printk(KERN_ERR "%s Unable to allocate memory for struct\n",
__func__);
return -ENOMEM;
}
for (i = 0; i < MAX_SESSIONS; i++)
msm_rotator_dev->rot_session[i] = NULL;
msm_rotator_dev->last_session_idx = INVALID_SESSION;
pdata = pdev->dev.platform_data;
number_of_clks = pdata->number_of_clocks;
rot_iommu_split_domain = pdata->rot_iommu_split_domain;
msm_rotator_dev->imem_owner = IMEM_NO_OWNER;
mutex_init(&msm_rotator_dev->imem_lock);
INIT_LIST_HEAD(&msm_rotator_dev->fd_list);
msm_rotator_dev->imem_clk_state = CLK_DIS;
INIT_DELAYED_WORK(&msm_rotator_dev->imem_clk_work,
msm_rotator_imem_clk_work_f);
msm_rotator_dev->imem_clk = NULL;
msm_rotator_dev->pdev = pdev;
msm_rotator_dev->core_clk = NULL;
msm_rotator_dev->pclk = NULL;
mrd->y_rot_buf = kmalloc(sizeof(struct rot_buf_type), GFP_KERNEL);
mrd->chroma_rot_buf = kmalloc(sizeof(struct rot_buf_type), GFP_KERNEL);
mrd->chroma2_rot_buf = kmalloc(sizeof(struct rot_buf_type), GFP_KERNEL);
memset((void *)mrd->y_rot_buf, 0, sizeof(struct rot_buf_type));
memset((void *)mrd->chroma_rot_buf, 0, sizeof(struct rot_buf_type));
memset((void *)mrd->chroma2_rot_buf, 0, sizeof(struct rot_buf_type));
#ifdef CONFIG_MSM_BUS_SCALING
if (!msm_rotator_dev->bus_client_handle && pdata &&
pdata->bus_scale_table) {
msm_rotator_dev->bus_client_handle =
msm_bus_scale_register_client(
pdata->bus_scale_table);
if (!msm_rotator_dev->bus_client_handle) {
pr_err("%s not able to get bus scale handle\n",
__func__);
}
}
#endif
for (i = 0; i < number_of_clks; i++) {
if (pdata->rotator_clks[i].clk_type == ROTATOR_IMEM_CLK) {
msm_rotator_dev->imem_clk =
clk_get(&msm_rotator_dev->pdev->dev,
pdata->rotator_clks[i].clk_name);
if (IS_ERR(msm_rotator_dev->imem_clk)) {
rc = PTR_ERR(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk = NULL;
printk(KERN_ERR "%s: cannot get imem_clk "
"rc=%d\n", DRIVER_NAME, rc);
goto error_imem_clk;
}
if (pdata->rotator_clks[i].clk_rate)
clk_set_rate(msm_rotator_dev->imem_clk,
pdata->rotator_clks[i].clk_rate);
}
if (pdata->rotator_clks[i].clk_type == ROTATOR_PCLK) {
msm_rotator_dev->pclk =
clk_get(&msm_rotator_dev->pdev->dev,
pdata->rotator_clks[i].clk_name);
if (IS_ERR(msm_rotator_dev->pclk)) {
rc = PTR_ERR(msm_rotator_dev->pclk);
msm_rotator_dev->pclk = NULL;
printk(KERN_ERR "%s: cannot get pclk rc=%d\n",
DRIVER_NAME, rc);
goto error_pclk;
}
if (pdata->rotator_clks[i].clk_rate)
clk_set_rate(msm_rotator_dev->pclk,
pdata->rotator_clks[i].clk_rate);
}
if (pdata->rotator_clks[i].clk_type == ROTATOR_CORE_CLK) {
msm_rotator_dev->core_clk =
clk_get(&msm_rotator_dev->pdev->dev,
pdata->rotator_clks[i].clk_name);
if (IS_ERR(msm_rotator_dev->core_clk)) {
rc = PTR_ERR(msm_rotator_dev->core_clk);
msm_rotator_dev->core_clk = NULL;
printk(KERN_ERR "%s: cannot get core clk "
"rc=%d\n", DRIVER_NAME, rc);
goto error_core_clk;
}
if (pdata->rotator_clks[i].clk_rate)
clk_set_rate(msm_rotator_dev->core_clk,
pdata->rotator_clks[i].clk_rate);
}
}
msm_rotator_dev->regulator = regulator_get(&msm_rotator_dev->pdev->dev,
"vdd");
if (IS_ERR(msm_rotator_dev->regulator))
msm_rotator_dev->regulator = NULL;
msm_rotator_dev->rot_clk_state = CLK_DIS;
INIT_DELAYED_WORK(&msm_rotator_dev->rot_clk_work,
msm_rotator_rot_clk_work_f);
mutex_init(&msm_rotator_dev->rotator_lock);
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
msm_rotator_dev->client = msm_ion_client_create(-1, pdev->name);
#endif
platform_set_drvdata(pdev, msm_rotator_dev);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
printk(KERN_ALERT
"%s: could not get IORESOURCE_MEM\n", DRIVER_NAME);
rc = -ENODEV;
goto error_get_resource;
}
msm_rotator_dev->io_base = ioremap(res->start,
resource_size(res));
#ifdef CONFIG_MSM_ROTATOR_USE_IMEM
if (msm_rotator_dev->imem_clk)
clk_prepare_enable(msm_rotator_dev->imem_clk);
#endif
enable_rot_clks();
ver = ioread32(MSM_ROTATOR_HW_VERSION);
disable_rot_clks();
#ifdef CONFIG_MSM_ROTATOR_USE_IMEM
if (msm_rotator_dev->imem_clk)
clk_disable_unprepare(msm_rotator_dev->imem_clk);
#endif
if (ver != pdata->hardware_version_number)
pr_debug("%s: invalid HW version ver 0x%x\n",
DRIVER_NAME, ver);
rotator_hw_revision = ver;
rotator_hw_revision >>= 16; /* bit 31:16 */
rotator_hw_revision &= 0xff;
pr_info("%s: rotator_hw_revision=%x\n",
__func__, rotator_hw_revision);
msm_rotator_dev->irq = platform_get_irq(pdev, 0);
if (msm_rotator_dev->irq < 0) {
printk(KERN_ALERT "%s: could not get IORESOURCE_IRQ\n",
DRIVER_NAME);
rc = -ENODEV;
goto error_get_irq;
}
rc = request_irq(msm_rotator_dev->irq, msm_rotator_isr,
IRQF_TRIGGER_RISING, DRIVER_NAME, NULL);
if (rc) {
printk(KERN_ERR "%s: request_irq() failed\n", DRIVER_NAME);
goto error_get_irq;
}
/* we enable the IRQ when we need it in the ioctl */
disable_irq(msm_rotator_dev->irq);
rc = alloc_chrdev_region(&msm_rotator_dev->dev_num, 0, 1, DRIVER_NAME);
if (rc < 0) {
printk(KERN_ERR "%s: alloc_chrdev_region Failed rc = %d\n",
__func__, rc);
goto error_get_irq;
}
msm_rotator_dev->class = class_create(THIS_MODULE, DRIVER_NAME);
if (IS_ERR(msm_rotator_dev->class)) {
rc = PTR_ERR(msm_rotator_dev->class);
printk(KERN_ERR "%s: couldn't create class rc = %d\n",
DRIVER_NAME, rc);
goto error_class_create;
}
msm_rotator_dev->device = device_create(msm_rotator_dev->class, NULL,
msm_rotator_dev->dev_num, NULL,
DRIVER_NAME);
if (IS_ERR(msm_rotator_dev->device)) {
rc = PTR_ERR(msm_rotator_dev->device);
printk(KERN_ERR "%s: device_create failed %d\n",
DRIVER_NAME, rc);
goto error_class_device_create;
}
cdev_init(&msm_rotator_dev->cdev, &msm_rotator_fops);
rc = cdev_add(&msm_rotator_dev->cdev,
MKDEV(MAJOR(msm_rotator_dev->dev_num), 0),
1);
if (rc < 0) {
printk(KERN_ERR "%s: cdev_add failed %d\n", __func__, rc);
goto error_cdev_add;
}
init_waitqueue_head(&msm_rotator_dev->wq);
INIT_WORK(&msm_rotator_dev->commit_work, rot_commit_wq_handler);
init_completion(&msm_rotator_dev->commit_comp);
mutex_init(&msm_rotator_dev->commit_mutex);
mutex_init(&msm_rotator_dev->commit_wq_mutex);
atomic_set(&msm_rotator_dev->commit_q_w, 0);
atomic_set(&msm_rotator_dev->commit_q_r, 0);
atomic_set(&msm_rotator_dev->commit_q_cnt, 0);
dev_dbg(msm_rotator_dev->device, "probe successful\n");
return rc;
error_cdev_add:
device_destroy(msm_rotator_dev->class, msm_rotator_dev->dev_num);
error_class_device_create:
class_destroy(msm_rotator_dev->class);
error_class_create:
unregister_chrdev_region(msm_rotator_dev->dev_num, 1);
error_get_irq:
iounmap(msm_rotator_dev->io_base);
error_get_resource:
mutex_destroy(&msm_rotator_dev->rotator_lock);
if (msm_rotator_dev->regulator)
regulator_put(msm_rotator_dev->regulator);
clk_put(msm_rotator_dev->core_clk);
error_core_clk:
clk_put(msm_rotator_dev->pclk);
error_pclk:
if (msm_rotator_dev->imem_clk)
clk_put(msm_rotator_dev->imem_clk);
error_imem_clk:
mutex_destroy(&msm_rotator_dev->imem_lock);
kfree(msm_rotator_dev);
return rc;
}
static int __devexit msm_rotator_remove(struct platform_device *plat_dev)
{
int i;
rot_wait_for_commit_queue(true);
#ifdef CONFIG_MSM_BUS_SCALING
if (msm_rotator_dev->bus_client_handle) {
msm_bus_scale_unregister_client
(msm_rotator_dev->bus_client_handle);
msm_rotator_dev->bus_client_handle = 0;
}
#endif
free_irq(msm_rotator_dev->irq, NULL);
mutex_destroy(&msm_rotator_dev->rotator_lock);
cdev_del(&msm_rotator_dev->cdev);
device_destroy(msm_rotator_dev->class, msm_rotator_dev->dev_num);
class_destroy(msm_rotator_dev->class);
unregister_chrdev_region(msm_rotator_dev->dev_num, 1);
iounmap(msm_rotator_dev->io_base);
if (msm_rotator_dev->imem_clk) {
if (msm_rotator_dev->imem_clk_state == CLK_EN)
clk_disable_unprepare(msm_rotator_dev->imem_clk);
clk_put(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk = NULL;
}
if (msm_rotator_dev->rot_clk_state == CLK_EN)
disable_rot_clks();
clk_put(msm_rotator_dev->core_clk);
clk_put(msm_rotator_dev->pclk);
if (msm_rotator_dev->regulator)
regulator_put(msm_rotator_dev->regulator);
msm_rotator_dev->core_clk = NULL;
msm_rotator_dev->pclk = NULL;
mutex_destroy(&msm_rotator_dev->imem_lock);
for (i = 0; i < MAX_SESSIONS; i++)
if (msm_rotator_dev->rot_session[i] != NULL)
kfree(msm_rotator_dev->rot_session[i]);
kfree(msm_rotator_dev);
return 0;
}
#ifdef CONFIG_PM
static int msm_rotator_suspend(struct platform_device *dev, pm_message_t state)
{
rot_wait_for_commit_queue(true);
mutex_lock(&msm_rotator_dev->imem_lock);
if (msm_rotator_dev->imem_clk_state == CLK_EN
&& msm_rotator_dev->imem_clk) {
clk_disable_unprepare(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk_state = CLK_SUSPEND;
}
mutex_unlock(&msm_rotator_dev->imem_lock);
mutex_lock(&msm_rotator_dev->rotator_lock);
if (msm_rotator_dev->rot_clk_state == CLK_EN) {
disable_rot_clks();
msm_rotator_dev->rot_clk_state = CLK_SUSPEND;
}
msm_rotator_release_all_timeline();
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
}
static int msm_rotator_resume(struct platform_device *dev)
{
mutex_lock(&msm_rotator_dev->imem_lock);
if (msm_rotator_dev->imem_clk_state == CLK_SUSPEND
&& msm_rotator_dev->imem_clk) {
clk_prepare_enable(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk_state = CLK_EN;
}
mutex_unlock(&msm_rotator_dev->imem_lock);
mutex_lock(&msm_rotator_dev->rotator_lock);
if (msm_rotator_dev->rot_clk_state == CLK_SUSPEND) {
enable_rot_clks();
msm_rotator_dev->rot_clk_state = CLK_EN;
}
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
}
#endif
static struct platform_driver msm_rotator_platform_driver = {
.probe = msm_rotator_probe,
.remove = __devexit_p(msm_rotator_remove),
#ifdef CONFIG_PM
.suspend = msm_rotator_suspend,
.resume = msm_rotator_resume,
#endif
.driver = {
.owner = THIS_MODULE,
.name = DRIVER_NAME
}
};
static int __init msm_rotator_init(void)
{
return platform_driver_register(&msm_rotator_platform_driver);
}
static void __exit msm_rotator_exit(void)
{
return platform_driver_unregister(&msm_rotator_platform_driver);
}
module_init(msm_rotator_init);
module_exit(msm_rotator_exit);
MODULE_DESCRIPTION("MSM Offline Image Rotator driver");
MODULE_VERSION("1.0");
MODULE_LICENSE("GPL v2");
| Java |
using System;
using Server;
using Server.Gumps;
using Server.Network;
namespace Server.Items
{
public class PowerScroll : Item
{
private SkillName m_Skill;
private double m_Value;
private static SkillName[] m_Skills = new SkillName[]
{
SkillName.Blacksmith,
SkillName.Tailoring,
SkillName.Swords,
SkillName.Fencing,
SkillName.Macing,
SkillName.Archery,
SkillName.Wrestling,
SkillName.Parry,
SkillName.Tactics,
SkillName.Anatomy,
SkillName.Healing,
SkillName.Magery,
SkillName.Meditation,
SkillName.EvalInt,
SkillName.MagicResist,
SkillName.AnimalTaming,
SkillName.AnimalLore,
SkillName.Veterinary,
SkillName.Musicianship,
SkillName.Provocation,
SkillName.Discordance,
SkillName.Peacemaking
};
private static SkillName[] m_AOSSkills = new SkillName[]
{
SkillName.Blacksmith,
SkillName.Tailoring,
SkillName.Swords,
SkillName.Fencing,
SkillName.Macing,
SkillName.Archery,
SkillName.Wrestling,
SkillName.Parry,
SkillName.Tactics,
SkillName.Anatomy,
SkillName.Healing,
SkillName.Magery,
SkillName.Meditation,
SkillName.EvalInt,
SkillName.MagicResist,
SkillName.AnimalTaming,
SkillName.AnimalLore,
SkillName.Veterinary,
SkillName.Musicianship,
SkillName.Provocation,
SkillName.Discordance,
SkillName.Peacemaking,
SkillName.Chivalry,
SkillName.Focus,
SkillName.Necromancy,
SkillName.Stealing,
SkillName.Stealth,
SkillName.SpiritSpeak
};
private static SkillName[] m_SESkills = new SkillName[]
{
SkillName.Blacksmith,
SkillName.Tailoring,
SkillName.Swords,
SkillName.Fencing,
SkillName.Macing,
SkillName.Archery,
SkillName.Wrestling,
SkillName.Parry,
SkillName.Tactics,
SkillName.Anatomy,
SkillName.Healing,
SkillName.Magery,
SkillName.Meditation,
SkillName.EvalInt,
SkillName.MagicResist,
SkillName.AnimalTaming,
SkillName.AnimalLore,
SkillName.Veterinary,
SkillName.Musicianship,
SkillName.Provocation,
SkillName.Discordance,
SkillName.Peacemaking,
SkillName.Chivalry,
SkillName.Focus,
SkillName.Necromancy,
SkillName.Stealing,
SkillName.Stealth,
SkillName.SpiritSpeak,
SkillName.Ninjitsu,
SkillName.Bushido
};
private static SkillName[] m_MLSkills = new SkillName[]
{
SkillName.Blacksmith,
SkillName.Tailoring,
SkillName.Swords,
SkillName.Fencing,
SkillName.Macing,
SkillName.Archery,
SkillName.Wrestling,
SkillName.Parry,
SkillName.Tactics,
SkillName.Anatomy,
SkillName.Healing,
SkillName.Magery,
SkillName.Meditation,
SkillName.EvalInt,
SkillName.MagicResist,
SkillName.AnimalTaming,
SkillName.AnimalLore,
SkillName.Veterinary,
SkillName.Musicianship,
SkillName.Provocation,
SkillName.Discordance,
SkillName.Peacemaking,
SkillName.Chivalry,
SkillName.Focus,
SkillName.Necromancy,
SkillName.Stealing,
SkillName.Stealth,
SkillName.SpiritSpeak,
SkillName.Ninjitsu,
SkillName.Bushido,
SkillName.Spellweaving
};
public static SkillName[] Skills{ get{ return ( Core.ML ? m_MLSkills : Core.SE ? m_SESkills : Core.AOS ? m_AOSSkills : m_Skills ); } }
public static PowerScroll CreateRandom( int min, int max )
{
min /= 5;
max /= 5;
SkillName[] skills = PowerScroll.Skills;
return new PowerScroll( skills[Utility.Random( skills.Length )], 100 + (Utility.RandomMinMax( min, max ) * 5));
}
public static PowerScroll CreateRandomNoCraft( int min, int max )
{
min /= 5;
max /= 5;
SkillName[] skills = PowerScroll.Skills;
SkillName skillName;
do
{
skillName = skills[Utility.Random( skills.Length )];
} while ( skillName == SkillName.Blacksmith || skillName == SkillName.Tailoring );
return new PowerScroll( skillName, 100 + (Utility.RandomMinMax( min, max ) * 5));
}
[Constructable]
public PowerScroll( SkillName skill, double value ) : base( 0x14F0 )
{
base.Hue = 0x481;
base.Weight = 1.0;
m_Skill = skill;
m_Value = value;
if ( m_Value > 105.0 )
LootType = LootType.Cursed;
}
public PowerScroll( Serial serial ) : base( serial )
{
}
[CommandProperty( AccessLevel.GameMaster )]
public SkillName Skill
{
get
{
return m_Skill;
}
set
{
m_Skill = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public double Value
{
get
{
return m_Value;
}
set
{
m_Value = value;
}
}
private string GetNameLocalized()
{
return String.Concat( "#", (1044060 + (int)m_Skill).ToString() );
}
private string GetName()
{
int index = (int)m_Skill;
SkillInfo[] table = SkillInfo.Table;
if ( index >= 0 && index < table.Length )
return table[index].Name.ToLower();
else
return "???";
}
public override void AddNameProperty(ObjectPropertyList list)
{
if ( m_Value == 105.0 )
list.Add( 1049639, GetNameLocalized() ); // a wonderous scroll of ~1_type~ (105 Skill)
else if ( m_Value == 110.0 )
list.Add( 1049640, GetNameLocalized() ); // an exalted scroll of ~1_type~ (110 Skill)
else if ( m_Value == 115.0 )
list.Add( 1049641, GetNameLocalized() ); // a mythical scroll of ~1_type~ (115 Skill)
else if ( m_Value == 120.0 )
list.Add( 1049642, GetNameLocalized() ); // a legendary scroll of ~1_type~ (120 Skill)
else
list.Add( "a power scroll of {0} ({1} Skill)", GetName(), m_Value );
}
public override void OnSingleClick( Mobile from )
{
if ( m_Value == 105.0 )
base.LabelTo( from, 1049639, GetNameLocalized() ); // a wonderous scroll of ~1_type~ (105 Skill)
else if ( m_Value == 110.0 )
base.LabelTo( from, 1049640, GetNameLocalized() ); // an exalted scroll of ~1_type~ (110 Skill)
else if ( m_Value == 115.0 )
base.LabelTo( from, 1049641, GetNameLocalized() ); // a mythical scroll of ~1_type~ (115 Skill)
else if ( m_Value == 120.0 )
base.LabelTo( from, 1049642, GetNameLocalized() ); // a legendary scroll of ~1_type~ (120 Skill)
else
base.LabelTo( from, "a power scroll of {0} ({1} Skill)", GetName(), m_Value );
}
public void Use( Mobile from, bool firstStage )
{
if ( Deleted )
return;
if ( IsChildOf( from.Backpack ) )
{
Skill skill = from.Skills[m_Skill];
if ( skill != null )
{
if ( skill.Cap >= m_Value )
{
from.SendLocalizedMessage( 1049511, GetNameLocalized() ); // Your ~1_type~ is too high for this power scroll.
}
else
{
if ( firstStage )
{
from.CloseGump( typeof( StatCapScroll.InternalGump ) );
from.CloseGump( typeof( PowerScroll.InternalGump ) );
from.SendGump( new InternalGump( from, this ) );
}
else
{
from.SendLocalizedMessage( 1049513, GetNameLocalized() ); // You feel a surge of magic as the scroll enhances your ~1_type~!
skill.Cap = m_Value;
Effects.SendLocationParticles( EffectItem.Create( from.Location, from.Map, EffectItem.DefaultDuration ), 0, 0, 0, 0, 0, 5060, 0 );
Effects.PlaySound( from.Location, from.Map, 0x243 );
Effects.SendMovingParticles( new Entity( Serial.Zero, new Point3D( from.X - 6, from.Y - 6, from.Z + 15 ), from.Map ), from, 0x36D4, 7, 0, false, true, 0x497, 0, 9502, 1, 0, (EffectLayer)255, 0x100 );
Effects.SendMovingParticles( new Entity( Serial.Zero, new Point3D( from.X - 4, from.Y - 6, from.Z + 15 ), from.Map ), from, 0x36D4, 7, 0, false, true, 0x497, 0, 9502, 1, 0, (EffectLayer)255, 0x100 );
Effects.SendMovingParticles( new Entity( Serial.Zero, new Point3D( from.X - 6, from.Y - 4, from.Z + 15 ), from.Map ), from, 0x36D4, 7, 0, false, true, 0x497, 0, 9502, 1, 0, (EffectLayer)255, 0x100 );
Effects.SendTargetParticles( from, 0x375A, 35, 90, 0x00, 0x00, 9502, (EffectLayer)255, 0x100 );
Delete();
}
}
}
}
else
{
from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
}
}
public override void OnDoubleClick( Mobile from )
{
Use( from, true );
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 0 ); // version
writer.Write( (int) m_Skill );
writer.Write( (double) m_Value );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
switch ( version )
{
case 0:
{
m_Skill = (SkillName)reader.ReadInt();
m_Value = reader.ReadDouble();
break;
}
}
if ( m_Value == 105.0 )
{
LootType = LootType.Regular;
}
else
{
LootType = LootType.Cursed;
if ( Insured )
Insured = false;
}
}
public class InternalGump : Gump
{
private Mobile m_Mobile;
private PowerScroll m_Scroll;
public InternalGump( Mobile mobile, PowerScroll scroll ) : base( 25, 50 )
{
m_Mobile = mobile;
m_Scroll = scroll;
AddPage( 0 );
AddBackground( 25, 10, 420, 200, 5054 );
AddImageTiled( 33, 20, 401, 181, 2624 );
AddAlphaRegion( 33, 20, 401, 181 );
AddHtmlLocalized( 40, 48, 387, 100, 1049469, true, true ); /* Using a scroll increases the maximum amount of a specific skill or your maximum statistics.
* When used, the effect is not immediately seen without a gain of points with that skill or statistics.
* You can view your maximum skill values in your skills window.
* You can view your maximum statistic value in your statistics window.
*/
AddHtmlLocalized( 125, 148, 200, 20, 1049478, 0xFFFFFF, false, false ); // Do you wish to use this scroll?
AddButton( 100, 172, 4005, 4007, 1, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 135, 172, 120, 20, 1046362, 0xFFFFFF, false, false ); // Yes
AddButton( 275, 172, 4005, 4007, 0, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 310, 172, 120, 20, 1046363, 0xFFFFFF, false, false ); // No
double value = scroll.m_Value;
if ( value == 105.0 )
AddHtmlLocalized( 40, 20, 260, 20, 1049635, 0xFFFFFF, false, false ); // Wonderous Scroll (105 Skill):
else if ( value == 110.0 )
AddHtmlLocalized( 40, 20, 260, 20, 1049636, 0xFFFFFF, false, false ); // Exalted Scroll (110 Skill):
else if ( value == 115.0 )
AddHtmlLocalized( 40, 20, 260, 20, 1049637, 0xFFFFFF, false, false ); // Mythical Scroll (115 Skill):
else if ( value == 120.0 )
AddHtmlLocalized( 40, 20, 260, 20, 1049638, 0xFFFFFF, false, false ); // Legendary Scroll (120 Skill):
else
AddHtml( 40, 20, 260, 20, String.Format( "<basefont color=#FFFFFF>Power Scroll ({0} Skill):</basefont>", value ), false, false );
AddHtmlLocalized( 310, 20, 120, 20, 1044060 + (int)scroll.m_Skill, 0xFFFFFF, false, false );
}
public override void OnResponse( NetState state, RelayInfo info )
{
if ( info.ButtonID == 1 )
m_Scroll.Use( m_Mobile, false );
}
}
}
} | Java |
/* Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* 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.
*/
/*
[SENSOR]
Sensor Model:
Camera Module:
Lens Model:
Driver IC: = OV2655
PV Size = 640 x 480
Cap Size = 2048 x 1536
Output Format = YUYV
MCLK Speed = 24M
PV DVP_PCLK =
Cap DVP_PCLK =
PV Frame Rate = 30fps
Cap Frame Rate = 7.5fps
I2C Slave ID =
I2C Mode = 16Addr, 16Data
*/
#ifndef CAMSENSOR_OV2655
#define CAMSENSOR_OV2655
#define OV2655_WriteSettingTbl(pTbl) OV2655_WriteRegsTbl(pTbl,sizeof(pTbl)/sizeof(pTbl[0]))
enum ov2655_test_mode_t {
TEST_OFF,
TEST_1,
TEST_2,
TEST_3
};
enum ov2655_resolution_t {
QTR_SIZE,
FULL_SIZE,
HFR_60FPS,
HFR_90FPS,
HFR_120FPS,
INVALID_SIZE
};
/******************************************************************************
OV2655_WREG, *POV2655_WREG Definition
******************************************************************************/
typedef struct
{
unsigned int addr; /*Reg Addr :16Bit*/
unsigned int data; /*Reg Data :16Bit or 8Bit*/
unsigned int data_format; /*Reg Data Format:16Bit = 0,8Bit = 1*/
unsigned int delay_mask;
} OV2655_WREG, *POV2655_WREG;
/******************************************************************************
Initial Setting Table
******************************************************************************/
OV2655_WREG ov2655_init_tbl[] =
{
{0x308c,0x80,1,0},
{0x308d,0x0e,1,0},
{0x360b,0x00,1,0},
{0x30b0,0xff,1,0},
{0x30b1,0xff,1,0},
{0x30b2,0x04,1,0},
{0x300e,0x34,1,0},
{0x300f,0xa6,1,0},
{0x3010,0x81,1,0},
{0x3082,0x01,1,0},
{0x30f4,0x01,1,0},
{0x3090,0x43,1,0},
{0x3091,0xc0,1,0},
{0x30ac,0x42,1,0},
{0x30d1,0x08,1,0},
{0x30a8,0x54,1,0},
{0x3015,0x02,1,0},
{0x3093,0x00,1,0},
{0x307e,0xe5,1,0},
{0x3079,0x00,1,0},
{0x30aa,0x52,1,0},
{0x3017,0x40,1,0},
{0x30f3,0x83,1,0},
{0x306a,0x0c,1,0},
{0x306d,0x00,1,0},
{0x336a,0x3c,1,0},
{0x3076,0x6a,1,0},
{0x30d9,0x95,1,0},
{0x3016,0x52,1,0},
{0x3601,0x30,1,0},
{0x304e,0x88,1,0},
{0x30f1,0x82,1,0},
{0x306f,0x14,1,0},
{0x302a,0x02,1,0},
{0x302b,0x84,1,0},
{0x3012,0x10,1,0},
{0x3011,0x01,1,0},//15fps
//;AEC/AGC
{0x3013,0xf7,1,0},
{0x301c,0x13,1,0},
{0x301d,0x17,1,0},
{0x3070,0x5c,1,0},
{0x3072,0x4d,1,0},
//;D5060
{0x30af,0x00,1,0},
{0x3048,0x1f,1,0},
{0x3049,0x4e,1,0},
{0x304a,0x20,1,0},
{0x304f,0x20,1,0},
{0x304b,0x02,1,0},
{0x304c,0x00,1,0},
{0x304d,0x02,1,0},
{0x304f,0x20,1,0},
{0x30a3,0x10,1,0},
{0x3013,0xf7,1,0},
{0x3014,0xa4,1,0},
{0x3071,0x00,1,0},
{0x3070,0xb9,1,0},
{0x3073,0x00,1,0},
{0x3072,0x4d,1,0},
{0x301c,0x03,1,0},
{0x301d,0x06,1,0},
{0x304d,0x42,1,0},
{0x304a,0x40,1,0},
{0x304f,0x40,1,0},
{0x3095,0x07,1,0},
{0x3096,0x16,1,0},
{0x3097,0x1d,1,0},
//;Window Setup
{0x3020,0x01,1,0},
{0x3021,0x18,1,0},
{0x3022,0x00,1,0},
{0x3023,0x06,1,0},
{0x3024,0x06,1,0},
{0x3025,0x58,1,0},
{0x3026,0x02,1,0},
{0x3027,0x61,1,0},
{0x3088,0x02,1,0},
{0x3089,0x80,1,0},
{0x308a,0x01,1,0},
{0x308b,0xe0,1,0},
{0x3316,0x64,1,0},
{0x3317,0x25,1,0},
{0x3318,0x80,1,0},
{0x3319,0x08,1,0},
{0x331a,0x28,1,0},
{0x331b,0x1e,1,0},
{0x331c,0x00,1,0},
{0x331d,0x38,1,0},
{0x3100,0x00,1,0},
//awb
{0x3320,0xfa,1,0},
{0x3321,0x11,1,0},
{0x3322,0x92,1,0},
{0x3323,0x01,1,0},
{0x3324,0x97,1,0},
{0x3325,0x02,1,0},
{0x3326,0xff,1,0},
{0x3327,0x10,1,0},
{0x3328,0x11,1,0},
{0x3329,0x0f,1,0},
{0x332a,0x58,1,0},
{0x332b,0x55,1,0},
{0x332c,0x90,1,0},
{0x332d,0xc0,1,0},
{0x332e,0x46,1,0},
{0x332f,0x2f,1,0},
{0x3330,0x2f,1,0},
{0x3331,0x44,1,0},
{0x3332,0xff,1,0},
{0x3333,0x00,1,0},
{0x3334,0xf0,1,0},
{0x3335,0xf0,1,0},
{0x3336,0xf0,1,0},
{0x3337,0x40,1,0},
{0x3338,0x40,1,0},
{0x3339,0x40,1,0},
{0x333a,0x00,1,0},
{0x333b,0x00,1,0},
//cmx
{0x3380,0x06,1,0},
{0x3381,0x90,1,0},
{0x3382,0x18,1,0},
{0x3383,0x31,1,0},
{0x3384,0x84,1,0},
{0x3385,0xb5,1,0},
{0x3386,0xba,1,0},
{0x3387,0xd2,1,0},
{0x3388,0x17,1,0},
{0x3389,0x9c,1,0},
{0x338a,0x00,1,0},
//gamma
{0x334f,0x20,1,0},
{0x3340,0x06,1,0},
{0x3341,0x14,1,0},
{0x3342,0x2b,1,0},
{0x3343,0x42,1,0},
{0x3344,0x55,1,0},
{0x3345,0x65,1,0},
{0x3346,0x70,1,0},
{0x3347,0x7c,1,0},
{0x3348,0x86,1,0},
{0x3349,0x96,1,0},
{0x334a,0xa3,1,0},
{0x334b,0xaf,1,0},
{0x334c,0xc4,1,0},
{0x334d,0xd7,1,0},
{0x334e,0xe8,1,0},
//;Lens correction
//R
{0x3350,0x35,1,0},
{0x3351,0x29,1,0},
{0x3352,0x08,1,0},
{0x3353,0x24,1,0},
{0x3354,0x00,1,0},
{0x3355,0x85,1,0},
//G
{0x3356,0x34,1,0},
{0x3357,0x29,1,0},
{0x3358,0x0f,1,0},
{0x3359,0x1d,1,0},
{0x335a,0x00,1,0},
{0x335b,0x85,1,0},
//B
{0x335c,0x36,1,0},
{0x335d,0x2b,1,0},
{0x335e,0x08,1,0},
{0x335f,0x1b,1,0},
{0x3360,0x00,1,0},
{0x3361,0x85,1,0},
//lenc gain
{0x3363,0x03,1,0},
{0x3364,0x01,1,0},
{0x3365,0x02,1,0},
{0x3366,0x00,1,0},
{0x3362,0x90,1,0},//lenc for binning
//uv adjust
{0x338b,0x08,1,0},
{0x338c,0x10,1,0},
{0x338d,0x5f,1,0},
//Sharpness/De-noise
{0x3370,0xd0,1,0},
{0x3371,0x00,1,0},
{0x3372,0x00,1,0},
{0x3373,0x30,1,0},
{0x3374,0x10,1,0},
{0x3375,0x10,1,0},
{0x3376,0x08,1,0},
{0x3377,0x02,1,0},
{0x3378,0x04,1,0},
{0x3379,0x40,1,0},
//aec
{0x3018,0x70,1,0},
{0x3019,0x60,1,0},
{0x301a,0x85,1,0},
//;BLC
{0x3069,0x86,1,0},
{0x307c,0x13,1,0},
{0x3087,0x02,1,0},
//;blacksun
//;Avdd 2.55~3.0V
{0x3090,0x3b,1,0},
{0x30a8,0x54,1,0},
{0x30aa,0x82,1,0},
{0x30a3,0x91,1,0},
{0x30a1,0x41,1,0},
//;Other functions
{0x3300,0xfc,1,0},
{0x3302,0x11,1,0},
{0x3400,0x00,1,0},
{0x3606,0x20,1,0},
{0x3601,0x30,1,0},
{0x300e,0x34,1,0},
{0x30f3,0x83,1,0},
{0x304e,0x88,1,0},
};
/******************************************************************************
Preview Setting Table 30Fps
******************************************************************************/
OV2655_WREG ov2655_preview_tbl_30fps[] =
{
//pclk=18M
//framerate:15fps
//YUVVGA(640x480)
{0x300e,0x3a,1,0},
{0x3010,0x81,1,0},
{0x3012,0x10,1,0},
{0x3014,0xac,1,0},
{0x3015,0x11,1,0},
{0x3016,0x82,1,0},
{0x3023,0x06,1,0},
{0x3026,0x02,1,0},
{0x3027,0x5e,1,0},
{0x302a,0x02,1,0},
{0x302b,0xe4,1,0},
{0x330c,0x00,1,0},
{0x3301,0xff,1,0},
{0x3069,0x80,1,0},
{0x306f,0x14,1,0},
{0x3088,0x03,1,0},
{0x3089,0x20,1,0},
{0x308a,0x02,1,0},
{0x308b,0x58,1,0},
{0x308e,0x00,1,0},
{0x30a1,0x41,1,0},
{0x30a3,0x80,1,0},
{0x30d9,0x95,1,0},
{0x3302,0x11,1,0},
{0x3317,0x25,1,0},
{0x3318,0x80,1,0},
{0x3319,0x08,1,0},
{0x331d,0x38,1,0},
{0x3373,0x40,1,0},
{0x3376,0x05,1,0},
{0x3362,0x90,1,0},
//svga->vga
{0x3302,0x11,1,0},
{0x3088,0x02,1,0},
{0x3089,0x80,1,0},
{0x308a,0x01,1,0},
{0x308b,0xe0,1,0},
{0x331a,0x28,1,0},
{0x331b,0x1e,1,0},
{0x331c,0x00,1,0},
{0x3302,0x11,1,0},
//mipi
{0x363b,0x01,1,0},
{0x309e,0x08,1,0},
{0x3606,0x00,1,0},
{0x3630,0x35,1,0},
{0x3086,0x0f,1,0},
{0x3086,0x00,1,0},
{0x304e,0x04,1,0},
{0x363b,0x01,1,0},
{0x309e,0x08,1,0},
{0x3606,0x00,1,0},
{0x3084,0x01,1,0},
{0x3010,0x81,1,0},
{0x3011,0x00,1,0},
{0x3634,0x26,1,0},
{0x3086,0x0f,1,0},
{0x3086,0x00,1,0},
//avoid black screen slash
{0x3000,0x15,1,0},
{0x3002,0x02,1,0},
{0x3003,0x6a,1,0},
};
/******************************************************************************
Preview Setting Table 60Fps
******************************************************************************/
OV2655_WREG ov2655_preview_tbl_60fps[] =
{
};
/******************************************************************************
Preview Setting Table 90Fps
******************************************************************************/
OV2655_WREG ov2655_preview_tbl_90fps[] =
{
};
/******************************************************************************
Capture Setting Table
******************************************************************************/
OV2655_WREG ov2655_capture_tbl[]=
{
//pclk=24M
//framerate:7.5ps
{0x300e,0x34,1,0},
{0x3011,0x01,1,0},
{0x3010,0x81,1,0},
{0x3012,0x00,1,0},
{0x3015,0x02,1,0},
{0x3016,0xc2,1,0},
{0x3023,0x0c,1,0},
{0x3026,0x04,1,0},
{0x3027,0xbc,1,0},
{0x302a,0x04,1,0},
{0x302b,0xd4,1,0},
{0x3069,0x80,1,0},
{0x306f,0x54,1,0},
{0x3088,0x06,1,0},
{0x3089,0x40,1,0},
{0x308a,0x04,1,0},
{0x308b,0xb0,1,0},
{0x308e,0x64,1,0},
{0x30a1,0x41,1,0},
{0x30a3,0x80,1,0},
{0x30d9,0x95,1,0},
{0x3302,0x01,1,0},
{0x3317,0x4b,1,0},
{0x3318,0x00,1,0},
{0x3319,0x4c,1,0},
{0x331d,0x6c,1,0},
{0x3362,0x80,1,0},
{0x3373,0x40,1,0},
{0x3376,0x03,1,0},
};
/******************************************************************************
Contrast Setting
******************************************************************************/
OV2655_WREG ov2655_contrast_lv0_tbl[] =
{
//Contrast -4
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x14,1,0},
{0x3399,0x14,1,0},
};
OV2655_WREG ov2655_contrast_lv1_tbl[] =
{
//Contrast -3
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x14,1,0},
{0x3399,0x14,1,0},
};
OV2655_WREG ov2655_contrast_lv2_tbl[] =
{
//Contrast -2
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x18,1,0},
{0x3399,0x18,1,0},
};
OV2655_WREG ov2655_contrast_lv3_tbl[] =
{
//Contrast -1
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x1c,1,0},
{0x3399,0x1c,1,0},
};
OV2655_WREG ov2655_contrast_default_lv4_tbl[] =
{
//Contrast (Default)
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x04},
{0x3398,0x20,1,0},
{0x3399,0x20,1,0},
};
OV2655_WREG ov2655_contrast_lv5_tbl[] =
{
//Contrast +1
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x24,1,0},
{0x3399,0x24,1,0},
};
OV2655_WREG ov2655_contrast_lv6_tbl[] =
{
//Contrast +2
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x28,1,0},
{0x3399,0x28,1,0},
};
OV2655_WREG ov2655_contrast_lv7_tbl[] =
{
//Contrast +3
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x2c,1,0},
{0x3399,0x2c,1,0},
};
OV2655_WREG ov2655_contrast_lv8_tbl[] =
{
//Contrast +4
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x30,1,0},
{0x3399,0x30,1,0},
};
/******************************************************************************
Sharpness Setting
******************************************************************************/
OV2655_WREG ov2655_sharpness_lv0_tbl[] =
{
//Sharpness 0
{0x3306,0x00,1,0x08},
{0x3376,0x01,1,0},
{0x3377,0x00,1,0},
{0x3378,0x10,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG ov2655_sharpness_lv1_tbl[] =
{
//Sharpness 1
{0x3306,0x00,1,0x08},
{0x3376,0x02,1,0},
{0x3377,0x00,1,0},
{0x3378,0x08,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG ov2655_sharpness_default_lv2_tbl[] =
{
//Sharpness_Auto (Default)
{0x3306,0x00,1,0x08},
{0x3376,0x05,1,0},//0x04
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG ov2655_sharpness_lv3_tbl[] =
{
//Sharpness 3
{0x3306,0x00,1,0x08},
{0x3376,0x06,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG ov2655_sharpness_lv4_tbl[] =
{
//Sharpness 4
{0x3306,0x00,1,0x08},
{0x3376,0x08,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG ov2655_sharpness_lv5_tbl[] =
{
//Sharpness 5
{0x3306,0x00,1,0x08},
{0x3376,0x0a,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG ov2655_sharpness_lv6_tbl[] =
{
//Sharpness 5
{0x3306,0x00,1,0x08},
{0x3376,0x0c,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG ov2655_sharpness_lv7_tbl[] =
{
//Sharpness 7
{0x3306,0x00,1,0x08},
{0x3376,0x0e,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG ov2655_sharpness_lv8_tbl[] =
{
//Sharpness 8
{0x3306,0x00,1,0x08},
{0x3376,0x10,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
/******************************************************************************
Saturation Setting
******************************************************************************/
OV2655_WREG ov2655_saturation_lv0_tbl[] =
{
//Saturation x0.25
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x10,1,0},
{0x3395,0x10,1,0},
};
OV2655_WREG ov2655_saturation_lv1_tbl[] =
{
//Saturation x0.5
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x18,1,0},
{0x3395,0x18,1,0},
};
OV2655_WREG ov2655_saturation_lv2_tbl[] =
{
//Saturation x0.75
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x20,1,0},
{0x3395,0x20,1,0},
};
OV2655_WREG ov2655_saturation_lv3_tbl[] =
{
//Saturation x0.75
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x30,1,0},
{0x3395,0x30,1,0},
};
OV2655_WREG ov2655_saturation_default_lv4_tbl[] =
{
//Saturation x1 (Default)
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x40,1,0},
{0x3395,0x40,1,0},
};
OV2655_WREG ov2655_saturation_lv5_tbl[] =
{
//Saturation x1.25
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x50,1,0},
{0x3395,0x50,1,0},
};
OV2655_WREG ov2655_saturation_lv6_tbl[] =
{
//Saturation x1.5
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x58,1,0},
{0x3395,0x58,1,0},
};
OV2655_WREG ov2655_saturation_lv7_tbl[] =
{
//Saturation x1.25
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x60,1,0},
{0x3395,0x60,1,0},
};
OV2655_WREG ov2655_saturation_lv8_tbl[] =
{
//Saturation x1.5
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x68,1,0},
{0x3395,0x68,1,0},
};
/******************************************************************************
Brightness Setting
******************************************************************************/
OV2655_WREG ov2655_brightness_lv0_tbl[] =
{
//Brightness -4
{0x3391,0x04,1,0x04},
{0x3390,0x49,1,0x08},
{0x339a,0x28,1,0},
};
OV2655_WREG ov2655_brightness_lv1_tbl[] =
{
//Brightness -3
{0x3391,0x04,1,0x04},
{0x3390,0x49,1,0x08},
{0x339a,0x20,1,0},
};
OV2655_WREG ov2655_brightness_lv2_tbl[] =
{
//Brightness -2
{0x3391,0x04,1,0x04},
{0x3390,0x49,1,0x08},
{0x339a,0x18,1,0},
};
OV2655_WREG ov2655_brightness_lv3_tbl[] =
{
//Brightness -1
{0x3391,0x04,1,0x04},
{0x3390,0x49,1,0x08},
{0x339a,0x10,1,0},
};
OV2655_WREG ov2655_brightness_default_lv4_tbl[] =
{
//Brightness 0 (Default)
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x00,1,0},
};
OV2655_WREG ov2655_brightness_lv5_tbl[] =
{
//Brightness +1
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x10,1,0},
};
OV2655_WREG ov2655_brightness_lv6_tbl[] =
{
//Brightness +2
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x20,1,0},
};
OV2655_WREG ov2655_brightness_lv7_tbl[] =
{
//Brightness +3
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x28,1,0},
};
OV2655_WREG ov2655_brightness_lv8_tbl[] =
{
//Brightness +4
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x30,1,0},
};
/******************************************************************************
Exposure Compensation Setting
******************************************************************************/
OV2655_WREG ov2655_exposure_compensation_lv0_tbl[]=
{
//Exposure Compensation +1.7EV
{0x3018,0x98,1,0},
{0x3019,0x88,1,0},
{0x301a,0xd4,1,0},
};
OV2655_WREG ov2655_exposure_compensation_lv1_tbl[]=
{
//Exposure Compensation +1.0EV
{0x3018,0x88,1,0},
{0x3019,0x78,1,0},
{0x301a,0xd4,1,0},
};
OV2655_WREG ov2655_exposure_compensation_lv2_default_tbl[]=
{
//Exposure Compensation default
{0x3018,0x70,1,0},//0x78
{0x3019,0x60,1,0},//0x68
{0x301a,0x85,1,0},//0xa5
};
OV2655_WREG ov2655_exposure_compensation_lv3_tbl[]=
{
//Exposure Compensation -1.0EV
{0x3018,0x6a,1,0},
{0x3019,0x5a,1,0},
{0x301a,0xd4,1,0},
};
OV2655_WREG ov2655_exposure_compensation_lv4_tbl[]=
{
//Exposure Compensation -1.7EV
{0x3018,0x5a,1,0},
{0x3019,0x4a,1,0},
{0x301a,0xc2,1,0},
};
/******************************************************************************
ISO TYPE Setting
******************************************************************************/
OV2655_WREG ov2655_iso_type_auto[]=
{
//ISO Auto
};
OV2655_WREG ov2655_iso_type_100[]=
{
//ISO 100
};
OV2655_WREG ov2655_iso_type_200[]=
{
//ISO 200
};
OV2655_WREG ov2655_iso_type_400[]=
{
//ISO 400
};
OV2655_WREG ov2655_iso_type_800[]=
{
//ISO 800
};
OV2655_WREG ov2655_iso_type_1600[]=
{
//ISO 1600
};
/******************************************************************************
Auto Expourse Weight Setting
******************************************************************************/
OV2655_WREG ov2655_ae_average_tbl[] =
{
//Whole Image Average
{0x3030,0x55,1,0},
{0x3031,0x55,1,0},
{0x3032,0x55,1,0},
{0x3033,0x55,1,0},
};
OV2655_WREG ov2655_ae_centerweight_tbl[] =
{
//Whole Image Center More weight
{0x3030,0x00,1,0},
{0x3031,0x3c,1,0},
{0x3032,0x00,1,0},
{0x3033,0x00,1,0},
};
/******************************************************************************
Light Mode Setting
******************************************************************************/
OV2655_WREG ov2655_wb_Auto[]=
{
//CAMERA_WB_AUTO //1
{0x3306,0x00,1,0x02},
};
OV2655_WREG ov2655_wb_custom[]=
{
//CAMERA_WB_CUSTOM //2
{0x3306,0x02,1,0x02},
{0x3337,0x44,1,0},
{0x3338,0x40,1,0},
{0x3339,0x70,1,0},
};
OV2655_WREG ov2655_wb_inc[]=
{
//CAMERA_WB_INCANDESCENT //3
{0x3306,0x02,1,0x02},
{0x3337,0x52,1,0},
{0x3338,0x40,1,0},
{0x3339,0x58,1,0},
};
OV2655_WREG ov2655_wb_fluorescent[]=
{
//CAMERA_WB_FLUORESCENT //4
{0x3306,0x02,1,0x02},
{0x3337,0x44,1,0},
{0x3338,0x40,1,0},
{0x3339,0x70,1,0},
};
OV2655_WREG ov2655_wb_daylight[]=
{
//CAMERA_WB_DAYLIGHT //5
{0x3306,0x02,1,0x02},
{0x3337,0x5e,1,0},
{0x3338,0x40,1,0},
{0x3339,0x46,1,0},
};
OV2655_WREG ov2655_wb_cloudy[]=
{
//CAMERA_WB_CLOUDY_DAYLIGHT //6
// {0x3306,0x02,1,0x02},
// {0x3337,0x68,1,0},
// {0x3338,0x40,1,0},
// {0x3339,0x4e,1,0},
{0x3306,0x02,1,0x02},
{0x3337,0x78,1,0},
{0x3338,0x50,1,0},
{0x3339,0x48,1,0},
};
OV2655_WREG ov2655_wb_twilight[]=
{
//CAMERA_WB_TWILIGHT //7
};
OV2655_WREG ov2655_wb_shade[]=
{
//CAMERA_WB_SHADE //8
};
/******************************************************************************
EFFECT Setting
******************************************************************************/
OV2655_WREG ov2655_effect_normal_tbl[] =
{
//CAMERA_EFFECT_OFF 0
{0x3391,0x00,1,0x78},
};
OV2655_WREG ov2655_effect_mono_tbl[] =
{
//CAMERA_EFFECT_MONO 1
{0x3391,0x20,1,0x78},
};
OV2655_WREG ov2655_effect_negative_tbl[] =
{
//CAMERA_EFFECT_NEGATIVE 2
{0x3391,0x40,1,0x78},
};
OV2655_WREG ov2655_effect_solarize_tbl[] =
{
//CAMERA_EFFECT_SOLARIZE 3
};
OV2655_WREG ov2655_effect_sepia_tbl[] =
{
//CAMERA_EFFECT_SEPIA 4
{0x3391,0x18,1,0x78},
{0x3396,0x40,1,0},
{0x3397,0xa6,1,0},
};
OV2655_WREG ov2655_effect_posterize_tbl[] =
{
//CAMERA_EFFECT_POSTERIZE 5
};
OV2655_WREG ov2655_effect_whiteboard_tbl[] =
{
//CAMERA_EFFECT_WHITEBOARD 6
};
OV2655_WREG ov2655_effect_blackboard_tbl[] =
{
//CAMERA_EFFECT_BLACKBOARD 7
};
OV2655_WREG ov2655_effect_aqua_tbl[] =
{
//CAMERA_EFFECT_AQUA 8
};
OV2655_WREG ov2655_effect_bw_tbl[] =
{
//CAMERA_EFFECT_BW 10
};
OV2655_WREG ov2655_effect_bluish_tbl[] =
{
//CAMERA_EFFECT_BLUISH 12
{0x3391,0x18,1,0x78},
{0x3396,0xa0,1,0},
{0x3397,0x40,1,0},
};
OV2655_WREG ov2655_effect_reddish_tbl[] =
{
//CAMERA_EFFECT_REDDISH 13
{0x3391,0x18,1,0x78},
{0x3396,0x80,1,0},
{0x3397,0xc0,1,0},
};
OV2655_WREG ov2655_effect_greenish_tbl[] =
{
//CAMERA_EFFECT_GREENISH 14
{0x3391,0x18,1,0x78},
{0x3396,0x60,1,0},
{0x3397,0x60,1,0},
};
/******************************************************************************
AntiBanding Setting
******************************************************************************/
OV2655_WREG ov2655_antibanding_auto_tbl[] =
{
//Auto-XCLK24MHz
// {0x3014,0xc0,1,0xc0},
{0x3014,0x80,1,0xc0},
};
OV2655_WREG ov2655_antibanding_50z_tbl[] =
{
//Band 50Hz
{0x3014,0x80,1,0xc0},
};
OV2655_WREG ov2655_antibanding_60z_tbl[] =
{
//Band 60Hz
// {0x3014,0x00,1,0xc0},
{0x3014,0x80,1,0xc0},
};
/******************************************************************************
Lens_shading Setting
******************************************************************************/
OV2655_WREG ov2655_lens_shading_on_tbl[] =
{
//Lens_shading On
{0x3300,0x08,1,0x08},
};
OV2655_WREG ov2655_lens_shading_off_tbl[] =
{
//Lens_shading Off
{0x3300,0x00,1,0x08},
};
/******************************************************************************
Auto Focus Setting
******************************************************************************/
OV2655_WREG ov2655_afinit_tbl[] =
{
};
#endif /* CAMSENSOR_OV2655 */
| Java |
from django.db import models
from django.contrib.auth.models import User
class OrganisationType(models.Model):
type_desc = models.CharField(max_length=200)
def __unicode__(self):
return self.type_desc
class Address(models.Model):
street_address = models.CharField(max_length=100)
city = models.CharField(max_length=100)
pin = models.CharField(max_length=10)
province = models.CharField(max_length=100)
nationality = models.CharField(max_length=100)
def __unicode__(self):
return self.street_address + ',' + self.city
class HattiUser(models.Model):
user = models.OneToOneField(User)
address = models.ForeignKey(Address)
telephone = models.CharField(max_length=500)
date_joined = models.DateTimeField(auto_now_add=True)
fax = models.CharField(max_length=100)
avatar = models.CharField(max_length=100, null=True, blank=True)
tagline = models.CharField(max_length=140)
class Meta:
abstract = True
class AdminOrganisations(HattiUser):
title = models.CharField(max_length=200)
organisation_type = models.ForeignKey(OrganisationType)
def __unicode__(self):
return self.title
class Customer(HattiUser):
title = models.CharField(max_length=200, blank=True, null=True)
is_org = models.BooleanField();
org_type = models.ForeignKey(OrganisationType)
company = models.CharField(max_length = 200)
def __unicode__(self, arg):
return unicode(self.user)
| Java |
/****************************************************************************************
* Copyright (c) 2010 Maximilian Kossick <maximilian.kossick@googlemail.com> *
* *
* 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, see <http://www.gnu.org/licenses/>. *
****************************************************************************************/
#include "TestUnionJob.h"
#include "core/support/Debug.h"
#include "core/collections/CollectionLocation.h"
#include "synchronization/UnionJob.h"
#include "CollectionTestImpl.h"
#include "mocks/MockTrack.h"
#include "mocks/MockAlbum.h"
#include "mocks/MockArtist.h"
#include <KCmdLineArgs>
#include <KGlobal>
#include <QList>
#include <qtest_kde.h>
#include <gmock/gmock.h>
QTEST_KDEMAIN_CORE( TestUnionJob )
using ::testing::Return;
using ::testing::AnyNumber;
static QList<int> trackCopyCount;
namespace Collections {
class MyCollectionLocation : public CollectionLocation
{
public:
Collections::CollectionTestImpl *coll;
QString prettyLocation() const { return "foo"; }
bool isWritable() const { return true; }
bool remove( const Meta::TrackPtr &track )
{
coll->mc->acquireWriteLock();
//theoretically we should clean up the other maps as well...
TrackMap map = coll->mc->trackMap();
map.remove( track->uidUrl() );
coll->mc->setTrackMap( map );
coll->mc->releaseLock();
return true;
}
void copyUrlsToCollection(const QMap<Meta::TrackPtr, KUrl> &sources, const Transcoding::Configuration& conf)
{
Q_UNUSED( conf )
trackCopyCount << sources.count();
foreach( const Meta::TrackPtr &track, sources.keys() )
{
coll->mc->addTrack( track );
}
}
};
class MyCollectionTestImpl : public CollectionTestImpl
{
public:
MyCollectionTestImpl( const QString &id ) : CollectionTestImpl( id ) {}
CollectionLocation* location() const
{
MyCollectionLocation *r = new MyCollectionLocation();
r->coll = const_cast<MyCollectionTestImpl*>( this );
return r;
}
};
} //namespace Collections
void addMockTrack( Collections::CollectionTestImpl *coll, const QString &trackName, const QString &artistName, const QString &albumName )
{
Meta::MockTrack *track = new Meta::MockTrack();
::testing::Mock::AllowLeak( track );
Meta::TrackPtr trackPtr( track );
EXPECT_CALL( *track, name() ).Times( AnyNumber() ).WillRepeatedly( Return( trackName ) );
EXPECT_CALL( *track, uidUrl() ).Times( AnyNumber() ).WillRepeatedly( Return( trackName + "_" + artistName + "_" + albumName ) );
EXPECT_CALL( *track, isPlayable() ).Times( AnyNumber() ).WillRepeatedly( Return( true ) );
EXPECT_CALL( *track, playableUrl() ).Times( AnyNumber() ).WillRepeatedly( Return( KUrl( '/' + track->uidUrl() ) ) );
coll->mc->addTrack( trackPtr );
Meta::AlbumPtr albumPtr = coll->mc->albumMap().value( albumName );
Meta::MockAlbum *album;
Meta::TrackList albumTracks;
if( albumPtr )
{
album = dynamic_cast<Meta::MockAlbum*>( albumPtr.data() );
if( !album )
{
QFAIL( "expected a Meta::MockAlbum" );
return;
}
albumTracks = albumPtr->tracks();
}
else
{
album = new Meta::MockAlbum();
::testing::Mock::AllowLeak( album );
albumPtr = Meta::AlbumPtr( album );
EXPECT_CALL( *album, name() ).Times( AnyNumber() ).WillRepeatedly( Return( albumName ) );
EXPECT_CALL( *album, hasAlbumArtist() ).Times( AnyNumber() ).WillRepeatedly( Return( false ) );
EXPECT_CALL( *album, albumArtist() ).Times( AnyNumber() ).WillRepeatedly( Return( Meta::ArtistPtr() ) );
coll->mc->addAlbum( albumPtr );
}
albumTracks << trackPtr;
EXPECT_CALL( *album, tracks() ).Times( AnyNumber() ).WillRepeatedly( Return( albumTracks ) );
EXPECT_CALL( *track, album() ).Times( AnyNumber() ).WillRepeatedly( Return( albumPtr ) );
Meta::ArtistPtr artistPtr = coll->mc->artistMap().value( artistName );
Meta::MockArtist *artist;
Meta::TrackList artistTracks;
if( artistPtr )
{
artist = dynamic_cast<Meta::MockArtist*>( artistPtr.data() );
if( !artist )
{
QFAIL( "expected a Meta::MockArtist" );
return;
}
artistTracks = artistPtr->tracks();
}
else
{
artist = new Meta::MockArtist();
::testing::Mock::AllowLeak( artist );
artistPtr = Meta::ArtistPtr( artist );
EXPECT_CALL( *artist, name() ).Times( AnyNumber() ).WillRepeatedly( Return( artistName ) );
coll->mc->addArtist( artistPtr );
}
artistTracks << trackPtr;
EXPECT_CALL( *artist, tracks() ).Times( AnyNumber() ).WillRepeatedly( Return( artistTracks ) );
EXPECT_CALL( *track, artist() ).Times( AnyNumber() ).WillRepeatedly( Return( artistPtr ) );
}
TestUnionJob::TestUnionJob() : QObject()
{
KCmdLineArgs::init( KGlobal::activeComponent().aboutData() );
::testing::InitGoogleMock( &KCmdLineArgs::qtArgc(), KCmdLineArgs::qtArgv() );
qRegisterMetaType<Meta::TrackList>();
qRegisterMetaType<Meta::AlbumList>();
qRegisterMetaType<Meta::ArtistList>();
}
void
TestUnionJob::init()
{
trackCopyCount.clear();
}
void
TestUnionJob::testEmptyA()
{
Collections::CollectionTestImpl *collA = new Collections::MyCollectionTestImpl("A");
Collections::CollectionTestImpl *collB = new Collections::MyCollectionTestImpl("B");
addMockTrack( collB, "track1", "artist1", "album1" );
QCOMPARE( collA->mc->trackMap().count(), 0 );
QCOMPARE( collB->mc->trackMap().count(), 1 );
QVERIFY( trackCopyCount.isEmpty() );
UnionJob *job = new UnionJob( collA, collB );
job->synchronize();
QTest::kWaitForSignal( job, SIGNAL(destroyed()), 1000 );
QCOMPARE( trackCopyCount.size(), 1 );
QVERIFY( trackCopyCount.contains( 1 ) );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 1 );
delete collA;
delete collB;
}
void
TestUnionJob::testEmptyB()
{
Collections::CollectionTestImpl *collA = new Collections::MyCollectionTestImpl("A");
Collections::CollectionTestImpl *collB = new Collections::MyCollectionTestImpl("B");
addMockTrack( collA, "track1", "artist1", "album1" );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 0 );
QVERIFY( trackCopyCount.isEmpty() );
UnionJob *job = new UnionJob( collA, collB );
job->synchronize();
QTest::kWaitForSignal( job, SIGNAL(destroyed()), 1000 );
QCOMPARE( trackCopyCount.size(), 1 );
QVERIFY( trackCopyCount.contains( 1 ) );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 1 );
delete collA;
delete collB;
}
void
TestUnionJob::testAddTrackToBoth()
{
Collections::CollectionTestImpl *collA = new Collections::MyCollectionTestImpl("A");
Collections::CollectionTestImpl *collB = new Collections::MyCollectionTestImpl("B");
addMockTrack( collA, "track1", "artist1", "album1" );
addMockTrack( collB, "track2", "artist2", "album2" );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 1 );
QVERIFY( trackCopyCount.isEmpty() );
UnionJob *job = new UnionJob( collA, collB );
job->synchronize();
QTest::kWaitForSignal( job, SIGNAL(destroyed()), 1000 );
QCOMPARE( trackCopyCount.size(), 2 );
QCOMPARE( trackCopyCount.at( 0 ), 1 );
QCOMPARE( trackCopyCount.at( 1 ), 1 );
QCOMPARE( collA->mc->trackMap().count(), 2 );
QCOMPARE( collB->mc->trackMap().count(), 2 );
delete collA;
delete collB;
}
void
TestUnionJob::testTrackAlreadyInBoth()
{
Collections::CollectionTestImpl *collA = new Collections::MyCollectionTestImpl("A");
Collections::CollectionTestImpl *collB = new Collections::MyCollectionTestImpl("B");
addMockTrack( collA, "track1", "artist1", "album1" );
addMockTrack( collB, "track1", "artist1", "album1" );
addMockTrack( collB, "track2", "artist2", "album2" );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 2 );
QVERIFY( trackCopyCount.isEmpty() );
UnionJob *job = new UnionJob( collA, collB );
job->synchronize();
QTest::kWaitForSignal( job, SIGNAL(destroyed()), 1000 );
QCOMPARE( trackCopyCount.size(), 1 );
QVERIFY( trackCopyCount.contains( 1 ) );
QCOMPARE( collA->mc->trackMap().count(), 2 );
QCOMPARE( collB->mc->trackMap().count(), 2 );
delete collA;
delete collB;
}
| Java |
/* UOL Messenger
* Copyright (c) 2005 Universo Online S/A
*
* Direitos Autorais Reservados
* All rights reserved
*
* Este programa é software livre; você pode redistribuí-lo e/ou modificá-lo
* sob os termos da Licença Pública Geral GNU conforme publicada pela Free
* Software Foundation; tanto a versão 2 da Licença, como (a seu critério)
* qualquer versão posterior.
* Este programa é distribuído na expectativa de que seja útil, porém,
* SEM NENHUMA GARANTIA; nem mesmo a garantia implícita de COMERCIABILIDADE
* OU ADEQUAÇÃO A UMA FINALIDADE ESPECÍFICA. Consulte a Licença Pública Geral
* do GNU para mais detalhes.
* Você deve ter recebido uma cópia da Licença Pública Geral do GNU junto
* com este programa; se não, escreva para a Free Software Foundation, Inc.,
* no endereço 59 Temple Street, Suite 330, Boston, MA 02111-1307 USA.
*
* 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-1307, USA.
*
* Universo Online S/A - A/C: UOL Messenger 5o. Andar
* Avenida Brigadeiro Faria Lima, 1.384 - Jardim Paulistano
* São Paulo SP - CEP 01452-002 - BRASIL */
#include "StdAfx.h"
#include <commands/ShowFileTransfersDialogcommand.h>
#include "../UIMApplication.h"
CShowFileTransfersDialogCommand::CShowFileTransfersDialogCommand()
{
}
CShowFileTransfersDialogCommand::~CShowFileTransfersDialogCommand(void)
{
}
void CShowFileTransfersDialogCommand::Execute()
{
CUIMApplication::GetApplication()->GetUIManager()->ShowFileTransferDialog(NULL);
}
| Java |
---
title: "Postmortem: Sheepstacker"
description: "A discussion about the development of the iOS game Sheepstacker from Tiny Tim Games."
categories: Postmortems
tags: [Tiny Tim Games, Unity, indie, iOS, postmortem, game development]
published: 3-21-2009
---
*NOTE: The following postmortem was originally presented on the Tiny Tim Games website, and it discusses a game that is no longer available to purchase or download. It has been placed here as a reference.*
As Sheepstacker has been available in the App Store for over a month now, I thought it might be time to share a few of our experiences from working on the game. If you’re a budding indie game developer, or you’re just interested in how we do the things we do, then I hope you’ll enjoy the following “postmortem” on how we felt the development of Sheepstacker went.
## Necessity… Mother… Invention…
Sheepstacker was a game of necessity for us. I had been working as a gameplay programmer in the traditional gaming industry for over six years by the time we had begun work on Sheepstacker. For a long time, I had felt the burn-out from either working too many hours or simply working on projects that either had no end in sight or just weren’t all that interesting. But that’s how things go in the big console and PC industry; you’re always working on someone else’s game, which is fun for a while. However, if you have any creative ambition at all, eventually you want to do something more.
In addition to this, the industry itself began going through radical changes. The Wii rose to the top as the dominant console in the marketplace (much to the chagrin of many top-tier publishers and developers), and the entire industry seems to have made a shift from being exclusively hardcore to something everyone wants to do. Couple this market shift with an economic recession, and you’ve got an industry that looks healthy overall, but has lots of internal problems at some of the once-successful companies. I was a victim of this shift, as were [many][layoffs1] [others][layoffs2] in the [Great][layoffs3] [Tech][layoffs4] [Layoffs][layoffs5] of 2009.
So with pink slip in hand and the hiring market drying up all across the industry, my wife Shannon and I set out to achieve the indie game development dream. Our number one priority was to simply get something done and out there with the shortest development time possible. We needed three things to get this accomplished though: 1) a platform; 2) an engine or SDK; and 3) a game design.
The first two were easy. Shannon and I both had iPhones, and I had switched fully to Mac about two years ago. We had everything we needed to get going with the iPhone SDK. As for the engine, I had already been messing around with the desktop and iPhone versions of [Unity][unity] for a while at that point. I really liked the workflow advantages of Unity, and felt it was directly engineered toward making great playing and great looking games very quickly. We still needed a game design though.
I had at one time played [Digital Chocolate][digital-chocolate]‘s great mobile game Tower Bloxx. I was so impressed with its simple one-button, addictive gameplay that I wanted to do something similar, but add to it and put my own little twist on it. However, I was having trouble coming up with a theme. That’s when Shannon suggested that we stack sheep. The rest is, as they say, history.
The following are some of the top five things that went right and wrong during the development of Sheepstacker:
## What Went Right
### 1. The Unity Engine
As an indie starting out with Unity, you already start way ahead of the curve. While the editor in Unity is sleek, simple, and a pleasure to use, the real advantage with Unity comes from the myriad things it does to try to keep you focused on making the game, and not worrying about everything else.
Take, for example, importing assets. To import a texture, you simply save the Photoshop file into the Assets folder of your project. After setting a few import settings, you never have to worry about importing the asset again. Simply open up the file, edit it, and save it. Unity automagically detects the edited file and reimports it. And that’s it.
The same goes for the scripting system. Scripts are auto-compiled on save, so you don’t have to worry about and older build lying around. In addition to this, it’s extremely easy to expose variables to the editor, allowing you to not only tweak settings, but also tweak them while the game is running and immediately see the effect in-game. It also helps that the scripting system supports writing scripts in C#, which is just close enough to C/C++ for me to be comfortable.
Being able to run the game in the editor without having to export constantly to the iPhone was great as well, though the export process is fairly straightforward and automated. From input to output, Unity streamlined our development immensely and allowed us to finish Sheepstacker, from initial prototype to app submission, in only three weeks.
### 2. A Simple Game Design
The simple, one-button gameplay of Sheepstacker meant that we had a small, well-scoped game for our first time out on our own. We couldn’t possibly do a larger game or even a simple level-based game as it would simply require too much content. Neither of us had really done 3D artwork before, so we needed something that wouldn’t be demanding content-wise.
We also needed something we could keep the reigns on in case feature creep started to kick in. The prototype for Sheepstacker was finished the same night we came up with the design, and the basic swinging/stacking mechanic changed very little from start to finish. Because we had the core of the game up and running so quickly, and because it was immediately fun, we felt that we could continue adding to the game until we felt like we were done, and not have to struggle with the basic gameplay while also adding all of the bells and whistles to make it polished.
### 3. Blender
While to serious artists in the gaming industry, [Blender][blender] might be an odd choice, for someone who had no prior experience in 3D art, it turned out to be one of our most useful tools.
I had purchased [“The Essential Blender”][the-essential-blender] book nearly a month prior to beginning Sheepstacker in an effort to take the fact that we couldn’t do 3D artwork ourselves out of the equation. While the interface was initially very daunting, with some good tutorials in the book, I was able to fairly quickly overcome the learning curve and become rather confident in my own ability to create 3D art.
Pretty soon, I was wanting the Blender shortcuts and tools to start appearing in other programs. Once you’re acquainted with the intricacies of the Blender workflow, you realize it’s designed for speed, creating things and manipulating them as quickly as possible. Again, this is one of the things we needed most on our project, and Blender delivered in spades.
### 4. Playing To Our Strengths
While I’m a programmer by trade, I had always wanted to get into the realm of game design. While one could simply chalk this up to a case of a programmer thinking he can make a better game than the designers, I had actually spent my entire career paying very close attention to the design aspects of the things I worked on. I regularly spoke with designers to get their insights into why some things work and why some things didn’t work. I would listen to the results from focus tests. I would pass ideas by designers themselves to get their input on it. My goal was always to learn about games beyond what I was simply implementing.
As it turns out, both experiences paid off for Sheepstacker. I had the experience of a seasoned programmer and enough game design knowledge to be able to quickly see when ideas would or wouldn’t work. For instance, we had a black sheep in our game at one point. It was meant to be something that the player should dodge, to kind of mix up the gameplay a bit. However, it never quite felt right. In the end, I’m glad to say that I think the addition would have eventually become a subtraction overall to the simple, addictive gameplay we created.
Additionally, Shannon was able to do what she had been doing for a long time already: graphics art. While I was able to come up with some fairly respectable 3D models, I was absolutely terrible at coming up with textures for them. However, she was able to use her experience and knowledge to fill that gap. I think we nailed the whimsical, cartoony visual style we were going for, and a lot of that can be credited to her.
### 5. The Sheep
While this could have gone under the “Blender” heading, I wanted to specifically point this out. We had the prototype running for a few days before we put the sheep into the game. It was already fairly enjoyable at that point. But as soon as we put the sheep in, without animations or even textures, all of a sudden we had a laugh out loud funny and fun game. The first time we saw a sheep land too far to the side of the stack and roll off, I knew we had something special.
And it only got better. After we textured and rigged the sheep, I began playing around with animating it. I was surprised at how simple, subtle movements really added so much to the game. The way that the sheep’s ears flap in the wind as they fall, the bulgy eyes when they’re knocked from the stack, the simple plop they do when they land, these all added the sort of polish we needed to really make the game stand out when people saw it. If there was one thing we couldn’t mess up, it was the sheep, and I think we did an admirable job with them.
## What Went Wrong
### 1. No Lite Version At Launch
It was a mistake not launching the game with an accompanying “lite” version. What’s an even bigger mistake is that it took us so long to final make one and submit it. We knew we had a great game. We had done numerous focus tests, and everyone who played it loved it. That meant that everyone else would love it too, right?
Unfortunately, people have to play the game first before they realize just how fun and addictive it can be, and without a lite version, we had to rely solely on word of mouth. And being that we’re a tiny independent game developer doing all of this from our home office, there was simply no way to generate the word of mouth buzz to make the game successful. People need to try it for themselves. That’s a mistake we’re not going to make again.
### 2. Where’s The Twist?
While I initially stated that I wanted to do something like Tower Bloxx, but with a twist, unfortunately the “twist” simply became “look, I can stack sheep!” While we have lots of subtle but important gameplay tweaks to the formula, there’s nothing we can really point to and say, “Yes, it’s similar to this, but wait ’til you get a load of this!”
Thankfully, we added a bit of this in our 1.1 update with the “Baa-lance” mode. While there are other “tilt the iPhone to catch something” games on the market, we essentially took the classic stacking gameplay (including the combos and the penalties) and made something that was unique and fun.
### 3. No High Scores
This is one that I was beating myself up for all the way through the submission process. However, we simply couldn’t get it into the initial version of the game within the timeframe we were on. It turned out to be a highly requested feature, so I’m glad we were able to add it finally (along with the inclusion of badges).
### 4. Making Menus
While the menus and UI itself turned out really nicely in the game, the actual development and upkeep of them took far too much time out of our schedule. Unity doesn’t have a very good one-size-fits-all solution for UI, and maybe no engine can provide that. But even so, having to deal with the slightly archaic `GUITexture` and `GUIText` objects was neither quick nor easy.
I will say this, though: The menu system from Sheepstacker is highly portable. We should be able to bring it into our projects going forward with little to no upkeep required. So this negative definitely turned into a positive going forward.
### 5. Sound
I hate sound effects. More specifically, I hate finding and implementing sound effects. While sound effects are most definitely a necessity in any good game and can many times steal the show, I just simply do not have the knack for finding the right sound for the right occasion.
We scoured through hundreds, if not thousands, of sounds before we finally came up with the twenty or so sounds that finally made it into the game. In addition, it took us a long time to find the right music for the title screen. While we had found the in-game music relatively early on and were really pleased with it, we just couldn’t settle on the title screen music. The music we have now is sufficient, but I would have liked to have had something more thematically similar to the great music found in the game proper.
## Something New
We learned a lot of valuable lessons going forward from Sheepstacker. We’re immensely proud of what we created, and we think it’s an excellent game that’s simple enough for a wide variety of people to be able to pick it up, play it, and immediately identify with it and enjoy it. However, I think we can do a lot better, and I look forward to us doing just that on our future projects.
[layoffs1]: http://feeds.gawker.com/~r/kotaku/full/~3/mHMfD_9WXE0/lay-offs-strike-crystal-dynamics
[layoffs2]: http://feeds.gawker.com/~r/kotaku/full/~3/uPDuEH6pKi8/more-ea-cuts-go-live-today
[layoffs3]: http://feeds.gawker.com/~r/kotaku/full/~3/OyTb5APfXuA/amd-cutting-jobs-slashing-survivors-pay
[layoffs4]: http://feeds.gawker.com/~r/kotaku/full/~3/9XPsE4CnawI/sega-staff-cuts-confirmed
[layoffs5]: http://feeds.gawker.com/~r/kotaku/full/~3/-xmbg06okT4/flight-simulator-devs-grounded-by-microsoft-job-cuts
[unity]: http://www.unity3d.com
[blender]: http://www.blender.org
[the-essential-blender]: http://www.blender3d.org/e-shop/product_info.php?products_id=96&PHPSESSID=db3c31556dac7ec5d1a6f0ff8cb7a22c | Java |
/*
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#include "AccountMgr.h"
#include "ArenaTeam.h"
#include "ArenaTeamMgr.h"
#include "Battleground.h"
#include "CalendarMgr.h"
#include "Chat.h"
#include "Common.h"
#include "DatabaseEnv.h"
#include "Group.h"
#include "Guild.h"
#include "GuildMgr.h"
#include "Language.h"
#include "Log.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "Opcodes.h"
#include "Pet.h"
#include "PlayerDump.h"
#include "Player.h"
#include "ReputationMgr.h"
#include "ScriptMgr.h"
#include "SharedDefines.h"
#include "SocialMgr.h"
#include "SystemConfig.h"
#include "UpdateMask.h"
#include "Util.h"
#include "World.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#ifdef ELUNA
#include "LuaEngine.h"
#endif
class LoginQueryHolder : public SQLQueryHolder
{
private:
uint32 m_accountId;
ObjectGuid m_guid;
public:
LoginQueryHolder(uint32 accountId, ObjectGuid guid)
: m_accountId(accountId), m_guid(guid) { }
ObjectGuid GetGuid() const { return m_guid; }
uint32 GetAccountId() const { return m_accountId; }
bool Initialize();
};
bool LoginQueryHolder::Initialize()
{
SetSize(MAX_PLAYER_LOGIN_QUERY);
bool res = true;
uint32 lowGuid = m_guid.GetCounter();
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_FROM, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GROUP_MEMBER);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_GROUP, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_INSTANCE);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_BOUND_INSTANCES, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_AURAS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_AURAS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_SPELL);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_SPELLS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_QUESTSTATUS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_QUEST_STATUS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_QUESTSTATUS_DAILY);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_DAILY_QUEST_STATUS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_QUESTSTATUS_WEEKLY);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_WEEKLY_QUEST_STATUS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_QUESTSTATUS_MONTHLY);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_MONTHLY_QUEST_STATUS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_QUESTSTATUS_SEASONAL);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_SEASONAL_QUEST_STATUS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_REPUTATION);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_REPUTATION, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_INVENTORY);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_INVENTORY, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_ACTIONS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_ACTIONS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_MAILCOUNT);
stmt->setUInt32(0, lowGuid);
stmt->setUInt64(1, uint64(time(NULL)));
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_MAIL_COUNT, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_MAILDATE);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_MAIL_DATE, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_SOCIALLIST);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_SOCIAL_LIST, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_HOMEBIND);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_HOME_BIND, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_SPELLCOOLDOWNS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_SPELL_COOLDOWNS, stmt);
if (sWorld->getBoolConfig(CONFIG_DECLINED_NAMES_USED))
{
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_DECLINEDNAMES);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_DECLINED_NAMES, stmt);
}
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUILD_MEMBER);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_GUILD, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_ARENAINFO);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_ARENA_INFO, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_ACHIEVEMENTS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_ACHIEVEMENTS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_CRITERIAPROGRESS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_CRITERIA_PROGRESS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_EQUIPMENTSETS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_EQUIPMENT_SETS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_BGDATA);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_BG_DATA, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_GLYPHS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_GLYPHS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_TALENTS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_TALENTS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PLAYER_ACCOUNT_DATA);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_ACCOUNT_DATA, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_SKILLS);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_SKILLS, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_RANDOMBG);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_RANDOM_BG, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_BANNED);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_BANNED, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_QUESTSTATUSREW);
stmt->setUInt32(0, lowGuid);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_QUEST_STATUS_REW, stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ACCOUNT_INSTANCELOCKTIMES);
stmt->setUInt32(0, m_accountId);
res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOAD_INSTANCE_LOCK_TIMES, stmt);
return res;
}
void WorldSession::HandleCharEnum(PreparedQueryResult result)
{
WorldPacket data(SMSG_CHAR_ENUM, 100); // we guess size
uint8 num = 0;
data << num;
_legitCharacters.clear();
if (result)
{
do
{
ObjectGuid guid(HIGHGUID_PLAYER, (*result)[0].GetUInt32());
TC_LOG_INFO("network", "Loading %s from account %u.", guid.ToString().c_str(), GetAccountId());
if (Player::BuildEnumData(result, &data))
{
// Do not allow banned characters to log in
if (!(*result)[20].GetUInt32())
_legitCharacters.insert(guid);
if (!sWorld->HasCharacterNameData(guid)) // This can happen if characters are inserted into the database manually. Core hasn't loaded name data yet.
sWorld->AddCharacterNameData(guid, (*result)[1].GetString(), (*result)[4].GetUInt8(), (*result)[2].GetUInt8(), (*result)[3].GetUInt8(), (*result)[7].GetUInt8());
++num;
}
}
while (result->NextRow());
}
data.put<uint8>(0, num);
SendPacket(&data);
}
void WorldSession::HandleCharEnumOpcode(WorldPacket& /*recvData*/)
{
// remove expired bans
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_EXPIRED_BANS);
CharacterDatabase.Execute(stmt);
/// get all the data necessary for loading all characters (along with their pets) on the account
if (sWorld->getBoolConfig(CONFIG_DECLINED_NAMES_USED))
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ENUM_DECLINED_NAME);
else
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ENUM);
stmt->setUInt8(0, PET_SAVE_AS_CURRENT);
stmt->setUInt32(1, GetAccountId());
_charEnumCallback = CharacterDatabase.AsyncQuery(stmt);
}
void WorldSession::HandleCharCreateOpcode(WorldPacket& recvData)
{
CharacterCreateInfo createInfo;
recvData >> createInfo.Name
>> createInfo.Race
>> createInfo.Class
>> createInfo.Gender
>> createInfo.Skin
>> createInfo.Face
>> createInfo.HairStyle
>> createInfo.HairColor
>> createInfo.FacialHair
>> createInfo.OutfitId;
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_TEAMMASK))
{
if (uint32 mask = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED))
{
bool disabled = false;
switch (Player::TeamForRace(createInfo.Race))
{
case ALLIANCE:
disabled = (mask & (1 << 0)) != 0;
break;
case HORDE:
disabled = (mask & (1 << 1)) != 0;
break;
}
if (disabled)
{
SendCharCreate(CHAR_CREATE_DISABLED);
return;
}
}
}
ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(createInfo.Class);
if (!classEntry)
{
TC_LOG_ERROR("network", "Class (%u) not found in DBC while creating new char for account (ID: %u): wrong DBC files or cheater?", createInfo.Class, GetAccountId());
SendCharCreate(CHAR_CREATE_FAILED);
return;
}
ChrRacesEntry const* raceEntry = sChrRacesStore.LookupEntry(createInfo.Race);
if (!raceEntry)
{
TC_LOG_ERROR("network", "Race (%u) not found in DBC while creating new char for account (ID: %u): wrong DBC files or cheater?", createInfo.Race, GetAccountId());
SendCharCreate(CHAR_CREATE_FAILED);
return;
}
// prevent character creating Expansion race without Expansion account
if (raceEntry->expansion > Expansion())
{
TC_LOG_ERROR("network", "Expansion %u account:[%d] tried to Create character with expansion %u race (%u)", Expansion(), GetAccountId(), raceEntry->expansion, createInfo.Race);
SendCharCreate(CHAR_CREATE_EXPANSION);
return;
}
// prevent character creating Expansion class without Expansion account
if (classEntry->expansion > Expansion())
{
TC_LOG_ERROR("network", "Expansion %u account:[%d] tried to Create character with expansion %u class (%u)", Expansion(), GetAccountId(), classEntry->expansion, createInfo.Class);
SendCharCreate(CHAR_CREATE_EXPANSION_CLASS);
return;
}
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RACEMASK))
{
uint32 raceMaskDisabled = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK);
if ((1 << (createInfo.Race - 1)) & raceMaskDisabled)
{
SendCharCreate(CHAR_CREATE_DISABLED);
return;
}
}
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_CLASSMASK))
{
uint32 classMaskDisabled = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED_CLASSMASK);
if ((1 << (createInfo.Class - 1)) & classMaskDisabled)
{
SendCharCreate(CHAR_CREATE_DISABLED);
return;
}
}
// prevent character creating with invalid name
if (!normalizePlayerName(createInfo.Name))
{
TC_LOG_ERROR("network", "Account:[%d] but tried to Create character with empty [name] ", GetAccountId());
SendCharCreate(CHAR_NAME_NO_NAME);
return;
}
// check name limitations
ResponseCodes res = ObjectMgr::CheckPlayerName(createInfo.Name, true);
if (res != CHAR_NAME_SUCCESS)
{
SendCharCreate(res);
return;
}
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RESERVEDNAME) && sObjectMgr->IsReservedName(createInfo.Name))
{
SendCharCreate(CHAR_NAME_RESERVED);
return;
}
if (createInfo.Class == CLASS_DEATH_KNIGHT && !HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_HEROIC_CHARACTER))
{
// speedup check for heroic class disabled case
uint32 heroic_free_slots = sWorld->getIntConfig(CONFIG_HEROIC_CHARACTERS_PER_REALM);
if (heroic_free_slots == 0)
{
SendCharCreate(CHAR_CREATE_UNIQUE_CLASS_LIMIT);
return;
}
// speedup check for heroic class disabled case
uint32 req_level_for_heroic = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_MIN_LEVEL_FOR_HEROIC_CHARACTER);
if (req_level_for_heroic > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
{
SendCharCreate(CHAR_CREATE_LEVEL_REQUIREMENT);
return;
}
}
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHECK_NAME);
stmt->setString(0, createInfo.Name);
delete _charCreateCallback.GetParam(); // Delete existing if any, to make the callback chain reset to stage 0
_charCreateCallback.SetParam(new CharacterCreateInfo(std::move(createInfo)));
_charCreateCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
}
void WorldSession::HandleCharCreateCallback(PreparedQueryResult result, CharacterCreateInfo* createInfo)
{
/** This is a series of callbacks executed consecutively as a result from the database becomes available.
This is much more efficient than synchronous requests on packet handler, and much less DoS prone.
It also prevents data syncrhonisation errors.
*/
switch (_charCreateCallback.GetStage())
{
case 0:
{
if (result)
{
SendCharCreate(CHAR_CREATE_NAME_IN_USE);
delete createInfo;
_charCreateCallback.Reset();
return;
}
ASSERT(_charCreateCallback.GetParam() == createInfo);
PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_SUM_REALM_CHARACTERS);
stmt->setUInt32(0, GetAccountId());
_charCreateCallback.FreeResult();
_charCreateCallback.SetFutureResult(LoginDatabase.AsyncQuery(stmt));
_charCreateCallback.NextStage();
break;
}
case 1:
{
uint16 acctCharCount = 0;
if (result)
{
Field* fields = result->Fetch();
// SELECT SUM(x) is MYSQL_TYPE_NEWDECIMAL - needs to be read as string
const char* ch = fields[0].GetCString();
if (ch)
acctCharCount = atoi(ch);
}
if (acctCharCount >= sWorld->getIntConfig(CONFIG_CHARACTERS_PER_ACCOUNT))
{
SendCharCreate(CHAR_CREATE_ACCOUNT_LIMIT);
delete createInfo;
_charCreateCallback.Reset();
return;
}
ASSERT(_charCreateCallback.GetParam() == createInfo);
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_SUM_CHARS);
stmt->setUInt32(0, GetAccountId());
_charCreateCallback.FreeResult();
_charCreateCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
_charCreateCallback.NextStage();
break;
}
case 2:
{
if (result)
{
Field* fields = result->Fetch();
createInfo->CharCount = uint8(fields[0].GetUInt64()); // SQL's COUNT() returns uint64 but it will always be less than uint8.Max
if (createInfo->CharCount >= sWorld->getIntConfig(CONFIG_CHARACTERS_PER_REALM))
{
SendCharCreate(CHAR_CREATE_SERVER_LIMIT);
delete createInfo;
_charCreateCallback.Reset();
return;
}
}
bool allowTwoSideAccounts = !sWorld->IsPvPRealm() || HasPermission(rbac::RBAC_PERM_TWO_SIDE_CHARACTER_CREATION);
uint32 skipCinematics = sWorld->getIntConfig(CONFIG_SKIP_CINEMATICS);
_charCreateCallback.FreeResult();
if (!allowTwoSideAccounts || skipCinematics == 1 || createInfo->Class == CLASS_DEATH_KNIGHT)
{
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_CREATE_INFO);
stmt->setUInt32(0, GetAccountId());
stmt->setUInt32(1, (skipCinematics == 1 || createInfo->Class == CLASS_DEATH_KNIGHT) ? 10 : 1);
_charCreateCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
_charCreateCallback.NextStage();
return;
}
_charCreateCallback.NextStage();
HandleCharCreateCallback(PreparedQueryResult(NULL), createInfo); // Will jump to case 3
break;
}
case 3:
{
bool haveSameRace = false;
uint32 heroicReqLevel = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_MIN_LEVEL_FOR_HEROIC_CHARACTER);
bool hasHeroicReqLevel = (heroicReqLevel == 0);
bool allowTwoSideAccounts = !sWorld->IsPvPRealm() || HasPermission(rbac::RBAC_PERM_TWO_SIDE_CHARACTER_CREATION);
uint32 skipCinematics = sWorld->getIntConfig(CONFIG_SKIP_CINEMATICS);
bool checkHeroicReqs = createInfo->Class == CLASS_DEATH_KNIGHT && !HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_HEROIC_CHARACTER);
if (result)
{
uint32 team = Player::TeamForRace(createInfo->Race);
uint32 freeHeroicSlots = sWorld->getIntConfig(CONFIG_HEROIC_CHARACTERS_PER_REALM);
Field* field = result->Fetch();
uint8 accRace = field[1].GetUInt8();
if (checkHeroicReqs)
{
uint8 accClass = field[2].GetUInt8();
if (accClass == CLASS_DEATH_KNIGHT)
{
if (freeHeroicSlots > 0)
--freeHeroicSlots;
if (freeHeroicSlots == 0)
{
SendCharCreate(CHAR_CREATE_UNIQUE_CLASS_LIMIT);
delete createInfo;
_charCreateCallback.Reset();
return;
}
}
if (!hasHeroicReqLevel)
{
uint8 accLevel = field[0].GetUInt8();
if (accLevel >= heroicReqLevel)
hasHeroicReqLevel = true;
}
}
// need to check team only for first character
/// @todo what to if account already has characters of both races?
if (!allowTwoSideAccounts)
{
uint32 accTeam = 0;
if (accRace > 0)
accTeam = Player::TeamForRace(accRace);
if (accTeam != team)
{
SendCharCreate(CHAR_CREATE_PVP_TEAMS_VIOLATION);
delete createInfo;
_charCreateCallback.Reset();
return;
}
}
// search same race for cinematic or same class if need
/// @todo check if cinematic already shown? (already logged in?; cinematic field)
while ((skipCinematics == 1 && !haveSameRace) || createInfo->Class == CLASS_DEATH_KNIGHT)
{
if (!result->NextRow())
break;
field = result->Fetch();
accRace = field[1].GetUInt8();
if (!haveSameRace)
haveSameRace = createInfo->Race == accRace;
if (checkHeroicReqs)
{
uint8 acc_class = field[2].GetUInt8();
if (acc_class == CLASS_DEATH_KNIGHT)
{
if (freeHeroicSlots > 0)
--freeHeroicSlots;
if (freeHeroicSlots == 0)
{
SendCharCreate(CHAR_CREATE_UNIQUE_CLASS_LIMIT);
delete createInfo;
_charCreateCallback.Reset();
return;
}
}
if (!hasHeroicReqLevel)
{
uint8 acc_level = field[0].GetUInt8();
if (acc_level >= heroicReqLevel)
hasHeroicReqLevel = true;
}
}
}
}
if (checkHeroicReqs && !hasHeroicReqLevel)
{
SendCharCreate(CHAR_CREATE_LEVEL_REQUIREMENT);
delete createInfo;
_charCreateCallback.Reset();
return;
}
Player newChar(this);
newChar.GetMotionMaster()->Initialize();
if (!newChar.Create(sObjectMgr->GenerateLowGuid(HIGHGUID_PLAYER), createInfo))
{
// Player not create (race/class/etc problem?)
newChar.CleanupsBeforeDelete();
SendCharCreate(CHAR_CREATE_ERROR);
delete createInfo;
_charCreateCallback.Reset();
return;
}
if ((haveSameRace && skipCinematics == 1) || skipCinematics == 2)
newChar.setCinematic(1); // not show intro
newChar.SetAtLoginFlag(AT_LOGIN_FIRST); // First login
// Player created, save it now
newChar.SaveToDB(true);
createInfo->CharCount += 1;
SQLTransaction trans = LoginDatabase.BeginTransaction();
PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_REALM_CHARACTERS_BY_REALM);
stmt->setUInt32(0, GetAccountId());
stmt->setUInt32(1, realmID);
trans->Append(stmt);
stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_REALM_CHARACTERS);
stmt->setUInt32(0, createInfo->CharCount);
stmt->setUInt32(1, GetAccountId());
stmt->setUInt32(2, realmID);
trans->Append(stmt);
LoginDatabase.CommitTransaction(trans);
SendCharCreate(CHAR_CREATE_SUCCESS);
TC_LOG_INFO("entities.player.character", "Account: %d (IP: %s) Create Character:[%s] (GUID: %u)", GetAccountId(), GetRemoteAddress().c_str(), createInfo->Name.c_str(), newChar.GetGUIDLow());
sScriptMgr->OnPlayerCreate(&newChar);
sWorld->AddCharacterNameData(newChar.GetGUID(), newChar.GetName(), newChar.getGender(), newChar.getRace(), newChar.getClass(), newChar.getLevel());
newChar.CleanupsBeforeDelete();
delete createInfo;
_charCreateCallback.Reset();
break;
}
}
}
void WorldSession::HandleCharDeleteOpcode(WorldPacket& recvData)
{
ObjectGuid guid;
recvData >> guid;
// Initiating
uint32 initAccountId = GetAccountId();
// can't delete loaded character
if (ObjectAccessor::FindPlayer(guid))
{
sScriptMgr->OnPlayerFailedDelete(guid, initAccountId);
return;
}
uint32 accountId = 0;
uint8 level = 0;
std::string name;
// is guild leader
if (sGuildMgr->GetGuildByLeader(guid))
{
sScriptMgr->OnPlayerFailedDelete(guid, initAccountId);
SendCharDelete(CHAR_DELETE_FAILED_GUILD_LEADER);
return;
}
// is arena team captain
if (sArenaTeamMgr->GetArenaTeamByCaptain(guid))
{
sScriptMgr->OnPlayerFailedDelete(guid, initAccountId);
SendCharDelete(CHAR_DELETE_FAILED_ARENA_CAPTAIN);
return;
}
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_DATA_BY_GUID);
stmt->setUInt32(0, guid.GetCounter());
if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
{
Field* fields = result->Fetch();
accountId = fields[0].GetUInt32();
name = fields[1].GetString();
level = fields[2].GetUInt8();
}
// prevent deleting other players' characters using cheating tools
if (accountId != initAccountId)
{
sScriptMgr->OnPlayerFailedDelete(guid, initAccountId);
return;
}
TC_LOG_INFO("entities.player.character", "Account: %d, IP: %s deleted character: %s, %s, Level: %u", accountId, GetRemoteAddress().c_str(), name.c_str(), guid.ToString().c_str(), level);
// To prevent hook failure, place hook before removing reference from DB
sScriptMgr->OnPlayerDelete(guid, initAccountId); // To prevent race conditioning, but as it also makes sense, we hand the accountId over for successful delete.
// Shouldn't interfere with character deletion though
if (sLog->ShouldLog("entities.player.dump", LOG_LEVEL_INFO)) // optimize GetPlayerDump call
{
std::string dump;
if (PlayerDumpWriter().GetDump(guid.GetCounter(), dump))
sLog->outCharDump(dump.c_str(), accountId, guid.GetRawValue(), name.c_str());
}
sCalendarMgr->RemoveAllPlayerEventsAndInvites(guid);
Player::DeleteFromDB(guid, accountId);
SendCharDelete(CHAR_DELETE_SUCCESS);
}
void WorldSession::HandlePlayerLoginOpcode(WorldPacket& recvData)
{
if (PlayerLoading() || GetPlayer() != NULL)
{
TC_LOG_ERROR("network", "Player tries to login again, AccountId = %d", GetAccountId());
KickPlayer();
return;
}
m_playerLoading = true;
ObjectGuid playerGuid;
TC_LOG_DEBUG("network", "WORLD: Recvd Player Logon Message");
recvData >> playerGuid;
if (!IsLegitCharacterForAccount(playerGuid))
{
TC_LOG_ERROR("network", "Account (%u) can't login with that character (%s).", GetAccountId(), playerGuid.ToString().c_str());
KickPlayer();
return;
}
LoginQueryHolder *holder = new LoginQueryHolder(GetAccountId(), playerGuid);
if (!holder->Initialize())
{
delete holder; // delete all unprocessed queries
m_playerLoading = false;
return;
}
_charLoginCallback = CharacterDatabase.DelayQueryHolder(holder);
}
void WorldSession::HandlePlayerLogin(LoginQueryHolder* holder)
{
ObjectGuid playerGuid = holder->GetGuid();
Player* pCurrChar = new Player(this);
// for send server info and strings (config)
ChatHandler chH = ChatHandler(pCurrChar->GetSession());
// "GetAccountId() == db stored account id" checked in LoadFromDB (prevent login not own character using cheating tools)
if (!pCurrChar->LoadFromDB(playerGuid, holder))
{
SetPlayer(NULL);
KickPlayer(); // disconnect client, player no set to session and it will not deleted or saved at kick
delete pCurrChar; // delete it manually
delete holder; // delete all unprocessed queries
m_playerLoading = false;
return;
}
pCurrChar->GetMotionMaster()->Initialize();
pCurrChar->SendDungeonDifficulty(false);
WorldPacket data(SMSG_LOGIN_VERIFY_WORLD, 20);
data << pCurrChar->GetMapId();
data << pCurrChar->GetPositionX();
data << pCurrChar->GetPositionY();
data << pCurrChar->GetPositionZ();
data << pCurrChar->GetOrientation();
SendPacket(&data);
// load player specific part before send times
LoadAccountData(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_ACCOUNT_DATA), PER_CHARACTER_CACHE_MASK);
SendAccountDataTimes(PER_CHARACTER_CACHE_MASK);
data.Initialize(SMSG_FEATURE_SYSTEM_STATUS, 2); // added in 2.2.0
data << uint8(2); // unknown value
data << uint8(0); // enable(1)/disable(0) voice chat interface in client
SendPacket(&data);
// Send MOTD
{
data.Initialize(SMSG_MOTD, 50); // new in 2.0.1
data << (uint32)0;
uint32 linecount=0;
std::string str_motd = sWorld->GetMotd();
std::string::size_type pos, nextpos;
pos = 0;
while ((nextpos= str_motd.find('@', pos)) != std::string::npos)
{
if (nextpos != pos)
{
data << str_motd.substr(pos, nextpos-pos);
++linecount;
}
pos = nextpos+1;
}
if (pos<str_motd.length())
{
data << str_motd.substr(pos);
++linecount;
}
data.put(0, linecount);
SendPacket(&data);
TC_LOG_DEBUG("network", "WORLD: Sent motd (SMSG_MOTD)");
// send server info
if (sWorld->getIntConfig(CONFIG_ENABLE_SINFO_LOGIN) == 1)
chH.PSendSysMessage(_FULLVERSION);
TC_LOG_DEBUG("network", "WORLD: Sent server info");
}
//QueryResult* result = CharacterDatabase.PQuery("SELECT guildid, rank FROM guild_member WHERE guid = '%u'", pCurrChar->GetGUIDLow());
if (PreparedQueryResult resultGuild = holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_GUILD))
{
Field* fields = resultGuild->Fetch();
pCurrChar->SetInGuild(fields[0].GetUInt32());
pCurrChar->SetRank(fields[1].GetUInt8());
}
else if (pCurrChar->GetGuildId()) // clear guild related fields in case wrong data about non existed membership
{
pCurrChar->SetInGuild(0);
pCurrChar->SetRank(0);
}
if (pCurrChar->GetGuildId() != 0)
{
if (Guild* guild = sGuildMgr->GetGuildById(pCurrChar->GetGuildId()))
guild->SendLoginInfo(this);
else
{
// remove wrong guild data
TC_LOG_ERROR("network", "Player %s (GUID: %u) marked as member of not existing guild (id: %u), removing guild membership for player.", pCurrChar->GetName().c_str(), pCurrChar->GetGUIDLow(), pCurrChar->GetGuildId());
pCurrChar->SetInGuild(0);
}
}
data.Initialize(SMSG_LEARNED_DANCE_MOVES, 4+4);
data << uint32(0);
data << uint32(0);
SendPacket(&data);
pCurrChar->SendInitialPacketsBeforeAddToMap();
//Show cinematic at the first time that player login
if (!pCurrChar->getCinematic())
{
pCurrChar->setCinematic(1);
if (ChrClassesEntry const* cEntry = sChrClassesStore.LookupEntry(pCurrChar->getClass()))
{
if (cEntry->CinematicSequence)
pCurrChar->SendCinematicStart(cEntry->CinematicSequence);
else if (ChrRacesEntry const* rEntry = sChrRacesStore.LookupEntry(pCurrChar->getRace()))
pCurrChar->SendCinematicStart(rEntry->CinematicSequence);
// send new char string if not empty
if (!sWorld->GetNewCharString().empty())
chH.PSendSysMessage("%s", sWorld->GetNewCharString().c_str());
}
}
if (!pCurrChar->GetMap()->AddPlayerToMap(pCurrChar) || !pCurrChar->CheckInstanceLoginValid())
{
AreaTrigger const* at = sObjectMgr->GetGoBackTrigger(pCurrChar->GetMapId());
if (at)
pCurrChar->TeleportTo(at->target_mapId, at->target_X, at->target_Y, at->target_Z, pCurrChar->GetOrientation());
else
pCurrChar->TeleportTo(pCurrChar->m_homebindMapId, pCurrChar->m_homebindX, pCurrChar->m_homebindY, pCurrChar->m_homebindZ, pCurrChar->GetOrientation());
}
sObjectAccessor->AddObject(pCurrChar);
//TC_LOG_DEBUG("Player %s added to Map.", pCurrChar->GetName().c_str());
pCurrChar->SendInitialPacketsAfterAddToMap();
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_ONLINE);
stmt->setUInt32(0, pCurrChar->GetGUIDLow());
CharacterDatabase.Execute(stmt);
stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_ONLINE);
stmt->setUInt32(0, GetAccountId());
LoginDatabase.Execute(stmt);
pCurrChar->SetInGameTime(getMSTime());
// announce group about member online (must be after add to player list to receive announce to self)
if (Group* group = pCurrChar->GetGroup())
{
//pCurrChar->groupInfo.group->SendInit(this); // useless
group->SendUpdate();
group->ResetMaxEnchantingLevel();
}
// friend status
sSocialMgr->SendFriendStatus(pCurrChar, FRIEND_ONLINE, pCurrChar->GetGUIDLow(), true);
// Place character in world (and load zone) before some object loading
pCurrChar->LoadCorpse();
// setting Ghost+speed if dead
if (pCurrChar->m_deathState != ALIVE)
{
// not blizz like, we must correctly save and load player instead...
if (pCurrChar->getRace() == RACE_NIGHTELF)
pCurrChar->CastSpell(pCurrChar, 20584, true, nullptr);// auras SPELL_AURA_INCREASE_SPEED(+speed in wisp form), SPELL_AURA_INCREASE_SWIM_SPEED(+swim speed in wisp form), SPELL_AURA_TRANSFORM (to wisp form)
pCurrChar->CastSpell(pCurrChar, 8326, true, nullptr); // auras SPELL_AURA_GHOST, SPELL_AURA_INCREASE_SPEED(why?), SPELL_AURA_INCREASE_SWIM_SPEED(why?)
pCurrChar->SetMovement(MOVE_WATER_WALK);
}
pCurrChar->ContinueTaxiFlight();
// reset for all pets before pet loading
if (pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_PET_TALENTS))
Pet::resetTalentsForAllPetsOf(pCurrChar);
// Load pet if any (if player not alive and in taxi flight or another then pet will remember as temporary unsummoned)
pCurrChar->LoadPet();
// Set FFA PvP for non GM in non-rest mode
if (sWorld->IsFFAPvPRealm() && !pCurrChar->IsGameMaster() && !pCurrChar->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_RESTING))
pCurrChar->SetByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP);
if (pCurrChar->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP))
pCurrChar->SetContestedPvP();
// Apply at_login requests
if (pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_SPELLS))
{
pCurrChar->ResetSpells();
SendNotification(LANG_RESET_SPELLS);
}
if (pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_TALENTS))
{
pCurrChar->ResetTalents(true);
pCurrChar->SendTalentsInfoData(false); // original talents send already in to SendInitialPacketsBeforeAddToMap, resend reset state
SendNotification(LANG_RESET_TALENTS);
}
bool firstLogin = pCurrChar->HasAtLoginFlag(AT_LOGIN_FIRST);
if (firstLogin)
pCurrChar->RemoveAtLoginFlag(AT_LOGIN_FIRST);
// show time before shutdown if shutdown planned.
if (sWorld->IsShuttingDown())
sWorld->ShutdownMsg(true, pCurrChar);
if (sWorld->getBoolConfig(CONFIG_ALL_TAXI_PATHS))
pCurrChar->SetTaxiCheater(true);
if (pCurrChar->IsGameMaster())
SendNotification(LANG_GM_ON);
std::string IP_str = GetRemoteAddress();
TC_LOG_INFO("entities.player.character", "Account: %d (IP: %s) Login Character:[%s] (GUID: %u) Level: %d",
GetAccountId(), IP_str.c_str(), pCurrChar->GetName().c_str(), pCurrChar->GetGUIDLow(), pCurrChar->getLevel());
if (!pCurrChar->IsStandState() && !pCurrChar->HasUnitState(UNIT_STATE_STUNNED))
pCurrChar->SetStandState(UNIT_STAND_STATE_STAND);
m_playerLoading = false;
// Handle Login-Achievements (should be handled after loading)
_player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN, 1);
sScriptMgr->OnPlayerLogin(pCurrChar, firstLogin);
delete holder;
}
void WorldSession::HandleSetFactionAtWar(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_SET_FACTION_ATWAR");
uint32 repListID;
uint8 flag;
recvData >> repListID;
recvData >> flag;
GetPlayer()->GetReputationMgr().SetAtWar(repListID, flag != 0);
}
//I think this function is never used :/ I dunno, but i guess this opcode not exists
void WorldSession::HandleSetFactionCheat(WorldPacket& /*recvData*/)
{
TC_LOG_ERROR("network", "WORLD SESSION: HandleSetFactionCheat, not expected call, please report.");
GetPlayer()->GetReputationMgr().SendStates();
}
void WorldSession::HandleTutorialFlag(WorldPacket& recvData)
{
uint32 data;
recvData >> data;
uint8 index = uint8(data / 32);
if (index >= MAX_ACCOUNT_TUTORIAL_VALUES)
return;
uint32 value = (data % 32);
uint32 flag = GetTutorialInt(index);
flag |= (1 << value);
SetTutorialInt(index, flag);
}
void WorldSession::HandleTutorialClear(WorldPacket& /*recvData*/)
{
for (uint8 i = 0; i < MAX_ACCOUNT_TUTORIAL_VALUES; ++i)
SetTutorialInt(i, 0xFFFFFFFF);
}
void WorldSession::HandleTutorialReset(WorldPacket& /*recvData*/)
{
for (uint8 i = 0; i < MAX_ACCOUNT_TUTORIAL_VALUES; ++i)
SetTutorialInt(i, 0x00000000);
}
void WorldSession::HandleSetWatchedFactionOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_SET_WATCHED_FACTION");
uint32 fact;
recvData >> fact;
GetPlayer()->SetUInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, fact);
}
void WorldSession::HandleSetFactionInactiveOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_SET_FACTION_INACTIVE");
uint32 replistid;
uint8 inactive;
recvData >> replistid >> inactive;
_player->GetReputationMgr().SetInactive(replistid, inactive != 0);
}
void WorldSession::HandleShowingHelmOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "CMSG_SHOWING_HELM for %s", _player->GetName().c_str());
recvData.read_skip<uint8>(); // unknown, bool?
_player->ToggleFlag(PLAYER_FLAGS, PLAYER_FLAGS_HIDE_HELM);
}
void WorldSession::HandleShowingCloakOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "CMSG_SHOWING_CLOAK for %s", _player->GetName().c_str());
recvData.read_skip<uint8>(); // unknown, bool?
_player->ToggleFlag(PLAYER_FLAGS, PLAYER_FLAGS_HIDE_CLOAK);
}
void WorldSession::HandleCharRenameOpcode(WorldPacket& recvData)
{
CharacterRenameInfo renameInfo;
recvData >> renameInfo.Guid
>> renameInfo.Name;
// prevent character rename to invalid name
if (!normalizePlayerName(renameInfo.Name))
{
SendCharRename(CHAR_NAME_NO_NAME, renameInfo);
return;
}
ResponseCodes res = ObjectMgr::CheckPlayerName(renameInfo.Name, true);
if (res != CHAR_NAME_SUCCESS)
{
SendCharRename(res, renameInfo);
return;
}
// check name limitations
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RESERVEDNAME) && sObjectMgr->IsReservedName(renameInfo.Name))
{
SendCharRename(CHAR_NAME_RESERVED, renameInfo);
return;
}
// Ensure that the character belongs to the current account, that rename at login is enabled
// and that there is no character with the desired new name
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_FREE_NAME);
stmt->setUInt32(0, renameInfo.Guid.GetCounter());
stmt->setUInt32(1, GetAccountId());
stmt->setUInt16(2, AT_LOGIN_RENAME);
stmt->setUInt16(3, AT_LOGIN_RENAME);
stmt->setString(4, renameInfo.Name);
delete _charRenameCallback.GetParam();
_charRenameCallback.SetParam(new CharacterRenameInfo(std::move(renameInfo)));
_charRenameCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
}
void WorldSession::HandleChangePlayerNameOpcodeCallBack(PreparedQueryResult result, CharacterRenameInfo const* renameInfo)
{
if (!result)
{
SendCharRename(CHAR_CREATE_ERROR, *renameInfo);
return;
}
Field* fields = result->Fetch();
uint32 guidLow = fields[0].GetUInt32();
std::string oldName = fields[1].GetString();
// Update name and at_login flag in the db
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_NAME);
stmt->setString(0, renameInfo->Name);
stmt->setUInt16(1, AT_LOGIN_RENAME);
stmt->setUInt32(2, guidLow);
CharacterDatabase.Execute(stmt);
// Removed declined name from db
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_DECLINED_NAME);
stmt->setUInt32(0, guidLow);
CharacterDatabase.Execute(stmt);
TC_LOG_INFO("entities.player.character", "Account: %d (IP: %s) Character:[%s] (%s) Changed name to: %s", GetAccountId(), GetRemoteAddress().c_str(), oldName.c_str(), renameInfo->Guid.ToString().c_str(), renameInfo->Name.c_str());
SendCharRename(RESPONSE_SUCCESS, *renameInfo);
sWorld->UpdateCharacterNameData(renameInfo->Guid, renameInfo->Name);
}
void WorldSession::HandleSetPlayerDeclinedNames(WorldPacket& recvData)
{
ObjectGuid guid;
recvData >> guid;
// not accept declined names for unsupported languages
std::string name;
if (!sObjectMgr->GetPlayerNameByGUID(guid, name))
{
SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, guid);
return;
}
std::wstring wname;
if (!Utf8toWStr(name, wname))
{
SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, guid);
return;
}
if (!isCyrillicCharacter(wname[0])) // name already stored as only single alphabet using
{
SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, guid);
return;
}
std::string name2;
DeclinedName declinedname;
recvData >> name2;
if (name2 != name) // character have different name
{
SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, guid);
return;
}
for (int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
{
recvData >> declinedname.name[i];
if (!normalizePlayerName(declinedname.name[i]))
{
SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, guid);
return;
}
}
if (!ObjectMgr::CheckDeclinedNames(wname, declinedname))
{
SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, guid);
return;
}
for (int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
CharacterDatabase.EscapeString(declinedname.name[i]);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_DECLINED_NAME);
stmt->setUInt32(0, guid.GetCounter());
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_DECLINED_NAME);
stmt->setUInt32(0, guid.GetCounter());
for (uint8 i = 0; i < 5; i++)
stmt->setString(i+1, declinedname.name[i]);
trans->Append(stmt);
CharacterDatabase.CommitTransaction(trans);
SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_SUCCESS, guid);
}
void WorldSession::HandleAlterAppearance(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "CMSG_ALTER_APPEARANCE");
uint32 Hair, Color, FacialHair, SkinColor;
recvData >> Hair >> Color >> FacialHair >> SkinColor;
BarberShopStyleEntry const* bs_hair = sBarberShopStyleStore.LookupEntry(Hair);
if (!bs_hair || bs_hair->type != 0 || bs_hair->race != _player->getRace() || bs_hair->gender != _player->getGender())
return;
BarberShopStyleEntry const* bs_facialHair = sBarberShopStyleStore.LookupEntry(FacialHair);
if (!bs_facialHair || bs_facialHair->type != 2 || bs_facialHair->race != _player->getRace() || bs_facialHair->gender != _player->getGender())
return;
BarberShopStyleEntry const* bs_skinColor = sBarberShopStyleStore.LookupEntry(SkinColor);
if (bs_skinColor && (bs_skinColor->type != 3 || bs_skinColor->race != _player->getRace() || bs_skinColor->gender != _player->getGender()))
return;
if (!Player::ValidateAppearance(_player->getRace(), _player->getClass(), _player->getGender(), bs_hair->hair_id, Color, uint8(_player->GetUInt32Value(PLAYER_FLAGS) >> 8), bs_facialHair->hair_id, bs_skinColor ? bs_skinColor->hair_id : 0))
return;
GameObject* go = _player->FindNearestGameObjectOfType(GAMEOBJECT_TYPE_BARBER_CHAIR, 5.0f);
if (!go)
{
SendBarberShopResult(BARBER_SHOP_RESULT_NOT_ON_CHAIR);
return;
}
if (_player->getStandState() != UNIT_STAND_STATE_SIT_LOW_CHAIR + go->GetGOInfo()->barberChair.chairheight)
{
SendBarberShopResult(BARBER_SHOP_RESULT_NOT_ON_CHAIR);
return;
}
uint32 cost = _player->GetBarberShopCost(bs_hair->hair_id, Color, bs_facialHair->hair_id, bs_skinColor);
// 0 - ok
// 1, 3 - not enough money
// 2 - you have to seat on barber chair
if (!_player->HasEnoughMoney(cost))
{
SendBarberShopResult(BARBER_SHOP_RESULT_NO_MONEY);
return;
}
SendBarberShopResult(BARBER_SHOP_RESULT_SUCCESS);
_player->ModifyMoney(-int32(cost)); // it isn't free
_player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER, cost);
_player->SetByteValue(PLAYER_BYTES, 2, uint8(bs_hair->hair_id));
_player->SetByteValue(PLAYER_BYTES, 3, uint8(Color));
_player->SetByteValue(PLAYER_BYTES_2, 0, uint8(bs_facialHair->hair_id));
if (bs_skinColor)
_player->SetByteValue(PLAYER_BYTES, 0, uint8(bs_skinColor->hair_id));
_player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP, 1);
_player->SetStandState(0); // stand up
}
void WorldSession::HandleRemoveGlyph(WorldPacket& recvData)
{
uint32 slot;
recvData >> slot;
if (slot >= MAX_GLYPH_SLOT_INDEX)
{
TC_LOG_DEBUG("network", "Client sent wrong glyph slot number in opcode CMSG_REMOVE_GLYPH %u", slot);
return;
}
if (uint32 glyph = _player->GetGlyph(slot))
{
if (GlyphPropertiesEntry const* gp = sGlyphPropertiesStore.LookupEntry(glyph))
{
_player->RemoveAurasDueToSpell(gp->SpellId);
_player->SetGlyph(slot, 0);
_player->SendTalentsInfoData(false);
}
}
}
void WorldSession::HandleCharCustomize(WorldPacket& recvData)
{
CharacterCustomizeInfo customizeInfo;
recvData >> customizeInfo.Guid;
if (!IsLegitCharacterForAccount(customizeInfo.Guid))
{
TC_LOG_ERROR("network", "Account %u, IP: %s tried to customise %s, but it does not belong to their account!",
GetAccountId(), GetRemoteAddress().c_str(), customizeInfo.Guid.ToString().c_str());
recvData.rfinish();
KickPlayer();
return;
}
recvData >> customizeInfo.Name
>> customizeInfo.Gender
>> customizeInfo.Skin
>> customizeInfo.HairColor
>> customizeInfo.HairStyle
>> customizeInfo.FacialHair
>> customizeInfo.Face;
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_NAME_DATA);
stmt->setUInt32(0, customizeInfo.Guid.GetCounter());
PreparedQueryResult result = CharacterDatabase.Query(stmt);
if (!result)
{
SendCharCustomize(CHAR_CREATE_ERROR, customizeInfo);
return;
}
Field* fields = result->Fetch();
uint8 plrRace = fields[0].GetUInt8();
uint8 plrClass = fields[1].GetUInt8();
uint8 plrGender = fields[2].GetUInt8();
if (!Player::ValidateAppearance(plrRace, plrClass, plrGender, customizeInfo.HairStyle, customizeInfo.HairColor, customizeInfo.Face, customizeInfo.FacialHair, customizeInfo.Skin, true))
{
SendCharCustomize(CHAR_CREATE_ERROR, customizeInfo);
return;
}
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_AT_LOGIN);
stmt->setUInt32(0, customizeInfo.Guid.GetCounter());
// TODO: Make async with callback
result = CharacterDatabase.Query(stmt);
if (!result)
{
SendCharCustomize(CHAR_CREATE_ERROR, customizeInfo);
return;
}
fields = result->Fetch();
uint32 at_loginFlags = fields[0].GetUInt16();
if (!(at_loginFlags & AT_LOGIN_CUSTOMIZE))
{
SendCharCustomize(CHAR_CREATE_ERROR, customizeInfo);
return;
}
// prevent character rename to invalid name
if (!normalizePlayerName(customizeInfo.Name))
{
SendCharCustomize(CHAR_NAME_NO_NAME, customizeInfo);
return;
}
ResponseCodes res = ObjectMgr::CheckPlayerName(customizeInfo.Name, true);
if (res != CHAR_NAME_SUCCESS)
{
SendCharCustomize(res, customizeInfo);
return;
}
// check name limitations
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RESERVEDNAME) && sObjectMgr->IsReservedName(customizeInfo.Name))
{
SendCharCustomize(CHAR_NAME_RESERVED, customizeInfo);
return;
}
// character with this name already exist
if (ObjectGuid newGuid = sObjectMgr->GetPlayerGUIDByName(customizeInfo.Name))
{
if (newGuid != customizeInfo.Guid)
{
SendCharCustomize(CHAR_CREATE_NAME_IN_USE, customizeInfo);
return;
}
}
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_NAME);
stmt->setUInt32(0, customizeInfo.Guid.GetCounter());
result = CharacterDatabase.Query(stmt);
if (result)
{
std::string oldname = result->Fetch()[0].GetString();
TC_LOG_INFO("entities.player.character", "Account: %d (IP: %s), Character[%s] (%s) Customized to: %s",
GetAccountId(), GetRemoteAddress().c_str(), oldname.c_str(), customizeInfo.Guid.ToString().c_str(), customizeInfo.Name.c_str());
}
SQLTransaction trans = CharacterDatabase.BeginTransaction();
Player::Customize(&customizeInfo, trans);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_NAME_AT_LOGIN);
stmt->setString(0, customizeInfo.Name);
stmt->setUInt16(1, uint16(AT_LOGIN_CUSTOMIZE));
stmt->setUInt32(2, customizeInfo.Guid.GetCounter());
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_DECLINED_NAME);
stmt->setUInt32(0, customizeInfo.Guid.GetCounter());
trans->Append(stmt);
CharacterDatabase.CommitTransaction(trans);
sWorld->UpdateCharacterNameData(customizeInfo.Guid, customizeInfo.Name, customizeInfo.Gender);
SendCharCustomize(RESPONSE_SUCCESS, customizeInfo);
}
void WorldSession::HandleEquipmentSetSave(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "CMSG_EQUIPMENT_SET_SAVE");
uint64 setGuid;
recvData.readPackGUID(setGuid);
uint32 index;
recvData >> index;
if (index >= MAX_EQUIPMENT_SET_INDEX) // client set slots amount
return;
std::string name;
recvData >> name;
std::string iconName;
recvData >> iconName;
EquipmentSet eqSet;
eqSet.Guid = setGuid;
eqSet.Name = name;
eqSet.IconName = iconName;
eqSet.state = EQUIPMENT_SET_NEW;
for (uint32 i = 0; i < EQUIPMENT_SLOT_END; ++i)
{
ObjectGuid itemGuid;
recvData >> itemGuid.ReadAsPacked();
// equipment manager sends "1" (as raw GUID) for slots set to "ignore" (don't touch slot at equip set)
if (itemGuid.GetRawValue() == 1)
{
// ignored slots saved as bit mask because we have no free special values for Items[i]
eqSet.IgnoreMask |= 1 << i;
continue;
}
Item* item = _player->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
if (!item && itemGuid) // cheating check 1
return;
if (item && item->GetGUID() != itemGuid) // cheating check 2
return;
eqSet.Items[i] = itemGuid.GetCounter();
}
_player->SetEquipmentSet(index, eqSet);
}
void WorldSession::HandleEquipmentSetDelete(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "CMSG_EQUIPMENT_SET_DELETE");
uint64 setGuid;
recvData.readPackGUID(setGuid);
_player->DeleteEquipmentSet(setGuid);
}
void WorldSession::HandleEquipmentSetUse(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "CMSG_EQUIPMENT_SET_USE");
for (uint32 i = 0; i < EQUIPMENT_SLOT_END; ++i)
{
ObjectGuid itemGuid;
recvData >> itemGuid.ReadAsPacked();
uint8 srcbag, srcslot;
recvData >> srcbag >> srcslot;
TC_LOG_DEBUG("entities.player.items", "%s: srcbag %u, srcslot %u", itemGuid.ToString().c_str(), srcbag, srcslot);
// check if item slot is set to "ignored" (raw value == 1), must not be unequipped then
if (itemGuid.GetRawValue() == 1)
continue;
// Only equip weapons in combat
if (_player->IsInCombat() && i != EQUIPMENT_SLOT_MAINHAND && i != EQUIPMENT_SLOT_OFFHAND && i != EQUIPMENT_SLOT_RANGED)
continue;
Item* item = _player->GetItemByGuid(itemGuid);
uint16 dstpos = i | (INVENTORY_SLOT_BAG_0 << 8);
if (!item)
{
Item* uItem = _player->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
if (!uItem)
continue;
ItemPosCountVec sDest;
InventoryResult msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, sDest, uItem, false);
if (msg == EQUIP_ERR_OK)
{
_player->RemoveItem(INVENTORY_SLOT_BAG_0, i, true);
_player->StoreItem(sDest, uItem, true);
}
else
_player->SendEquipError(msg, uItem, NULL);
continue;
}
if (item->GetPos() == dstpos)
continue;
_player->SwapItem(item->GetPos(), dstpos);
}
WorldPacket data(SMSG_EQUIPMENT_SET_USE_RESULT, 1);
data << uint8(0); // 4 - equipment swap failed - inventory is full
SendPacket(&data);
}
void WorldSession::HandleCharFactionOrRaceChange(WorldPacket& recvData)
{
CharacterFactionChangeInfo factionChangeInfo;
recvData >> factionChangeInfo.Guid;
if (!IsLegitCharacterForAccount(factionChangeInfo.Guid))
{
TC_LOG_ERROR("network", "Account %u, IP: %s tried to factionchange character %s, but it does not belong to their account!",
GetAccountId(), GetRemoteAddress().c_str(), factionChangeInfo.Guid.ToString().c_str());
recvData.rfinish();
KickPlayer();
return;
}
recvData >> factionChangeInfo.Name
>> factionChangeInfo.Gender
>> factionChangeInfo.Skin
>> factionChangeInfo.HairColor
>> factionChangeInfo.HairStyle
>> factionChangeInfo.FacialHair
>> factionChangeInfo.Face
>> factionChangeInfo.Race;
uint32 lowGuid = factionChangeInfo.Guid.GetCounter();
// get the players old (at this moment current) race
CharacterNameData const* nameData = sWorld->GetCharacterNameData(factionChangeInfo.Guid);
if (!nameData)
{
SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
return;
}
uint8 oldRace = nameData->m_race;
uint8 playerClass = nameData->m_class;
uint8 level = nameData->m_level;
// TO Do: Make async
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_AT_LOGIN_TITLES);
stmt->setUInt32(0, lowGuid);
PreparedQueryResult result = CharacterDatabase.Query(stmt);
if (!result)
{
SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
return;
}
Field* fields = result->Fetch();
uint32 at_loginFlags = fields[0].GetUInt16();
std::string knownTitlesStr = fields[1].GetString();
uint32 used_loginFlag = ((recvData.GetOpcode() == CMSG_CHAR_RACE_CHANGE) ? AT_LOGIN_CHANGE_RACE : AT_LOGIN_CHANGE_FACTION);
if (!sObjectMgr->GetPlayerInfo(factionChangeInfo.Race, playerClass))
{
SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
return;
}
if (!(at_loginFlags & used_loginFlag))
{
SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
return;
}
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RACEMASK))
{
uint32 raceMaskDisabled = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK);
if ((1 << (factionChangeInfo.Race - 1)) & raceMaskDisabled)
{
SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
return;
}
}
// prevent character rename to invalid name
if (!normalizePlayerName(factionChangeInfo.Name))
{
SendCharFactionChange(CHAR_NAME_NO_NAME, factionChangeInfo);
return;
}
ResponseCodes res = ObjectMgr::CheckPlayerName(factionChangeInfo.Name, true);
if (res != CHAR_NAME_SUCCESS)
{
SendCharFactionChange(res, factionChangeInfo);
return;
}
// check name limitations
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RESERVEDNAME) && sObjectMgr->IsReservedName(factionChangeInfo.Name))
{
SendCharFactionChange(CHAR_NAME_RESERVED, factionChangeInfo);
return;
}
// character with this name already exist
if (ObjectGuid newGuid = sObjectMgr->GetPlayerGUIDByName(factionChangeInfo.Name))
{
if (newGuid != factionChangeInfo.Guid)
{
SendCharFactionChange(CHAR_CREATE_NAME_IN_USE, factionChangeInfo);
return;
}
}
// resurrect the character in case he's dead
sObjectAccessor->ConvertCorpseForPlayer(factionChangeInfo.Guid);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
CharacterDatabase.EscapeString(factionChangeInfo.Name);
Player::Customize(&factionChangeInfo, trans);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_FACTION_OR_RACE);
stmt->setString(0, factionChangeInfo.Name);
stmt->setUInt8(1, factionChangeInfo.Race);
stmt->setUInt16(2, used_loginFlag);
stmt->setUInt32(3, lowGuid);
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_DECLINED_NAME);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
sWorld->UpdateCharacterNameData(factionChangeInfo.Guid, factionChangeInfo.Name, factionChangeInfo.Gender, factionChangeInfo.Race);
if (oldRace != factionChangeInfo.Race)
{
TeamId team = TEAM_ALLIANCE;
// Search each faction is targeted
switch (factionChangeInfo.Race)
{
case RACE_ORC:
case RACE_TAUREN:
case RACE_UNDEAD_PLAYER:
case RACE_TROLL:
case RACE_BLOODELF:
team = TEAM_HORDE;
break;
default:
break;
}
// Switch Languages
// delete all languages first
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SKILL_LANGUAGES);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
// Now add them back
stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_SKILL_LANGUAGE);
stmt->setUInt32(0, lowGuid);
// Faction specific languages
if (team == TEAM_HORDE)
stmt->setUInt16(1, 109);
else
stmt->setUInt16(1, 98);
trans->Append(stmt);
// Race specific languages
if (factionChangeInfo.Race != RACE_ORC && factionChangeInfo.Race != RACE_HUMAN)
{
stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_SKILL_LANGUAGE);
stmt->setUInt32(0, lowGuid);
switch (factionChangeInfo.Race)
{
case RACE_DWARF:
stmt->setUInt16(1, 111);
break;
case RACE_DRAENEI:
stmt->setUInt16(1, 759);
break;
case RACE_GNOME:
stmt->setUInt16(1, 313);
break;
case RACE_NIGHTELF:
stmt->setUInt16(1, 113);
break;
case RACE_UNDEAD_PLAYER:
stmt->setUInt16(1, 673);
break;
case RACE_TAUREN:
stmt->setUInt16(1, 115);
break;
case RACE_TROLL:
stmt->setUInt16(1, 315);
break;
case RACE_BLOODELF:
stmt->setUInt16(1, 137);
break;
}
trans->Append(stmt);
}
if (recvData.GetOpcode() == CMSG_CHAR_FACTION_CHANGE)
{
// Delete all Flypaths
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_TAXI_PATH);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
if (level > 7)
{
// Update Taxi path
// this doesn't seem to be 100% blizzlike... but it can't really be helped.
std::ostringstream taximaskstream;
uint32 numFullTaximasks = level / 7;
if (numFullTaximasks > 11)
numFullTaximasks = 11;
if (team == TEAM_ALLIANCE)
{
if (playerClass != CLASS_DEATH_KNIGHT)
{
for (uint8 i = 0; i < numFullTaximasks; ++i)
taximaskstream << uint32(sAllianceTaxiNodesMask[i]) << ' ';
}
else
{
for (uint8 i = 0; i < numFullTaximasks; ++i)
taximaskstream << uint32(sAllianceTaxiNodesMask[i] | sDeathKnightTaxiNodesMask[i]) << ' ';
}
}
else
{
if (playerClass != CLASS_DEATH_KNIGHT)
{
for (uint8 i = 0; i < numFullTaximasks; ++i)
taximaskstream << uint32(sHordeTaxiNodesMask[i]) << ' ';
}
else
{
for (uint8 i = 0; i < numFullTaximasks; ++i)
taximaskstream << uint32(sHordeTaxiNodesMask[i] | sDeathKnightTaxiNodesMask[i]) << ' ';
}
}
uint32 numEmptyTaximasks = 11 - numFullTaximasks;
for (uint8 i = 0; i < numEmptyTaximasks; ++i)
taximaskstream << "0 ";
taximaskstream << '0';
std::string taximask = taximaskstream.str();
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_TAXIMASK);
stmt->setString(0, taximask);
stmt->setUInt32(1, lowGuid);
trans->Append(stmt);
}
if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD))
{
// Reset guild
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUILD_MEMBER);
stmt->setUInt32(0, lowGuid);
PreparedQueryResult result = CharacterDatabase.Query(stmt);
if (result)
if (Guild* guild = sGuildMgr->GetGuildById((result->Fetch()[0]).GetUInt32()))
guild->DeleteMember(factionChangeInfo.Guid, false, false, true);
Player::LeaveAllArenaTeams(factionChangeInfo.Guid);
}
if (!HasPermission(rbac::RBAC_PERM_TWO_SIDE_ADD_FRIEND))
{
// Delete Friend List
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SOCIAL_BY_GUID);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SOCIAL_BY_FRIEND);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
}
// Reset homebind and position
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PLAYER_HOMEBIND);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PLAYER_HOMEBIND);
stmt->setUInt32(0, lowGuid);
WorldLocation loc;
uint16 zoneId = 0;
if (team == TEAM_ALLIANCE)
{
loc.WorldRelocate(0, -8867.68f, 673.373f, 97.9034f, 0.0f);
zoneId = 1519;
}
else
{
loc.WorldRelocate(1, 1633.33f, -4439.11f, 15.7588f, 0.0f);
zoneId = 1637;
}
stmt->setUInt16(1, loc.GetMapId());
stmt->setUInt16(2, zoneId);
stmt->setFloat(3, loc.GetPositionX());
stmt->setFloat(4, loc.GetPositionY());
stmt->setFloat(5, loc.GetPositionZ());
trans->Append(stmt);
Player::SavePositionInDB(loc, zoneId, factionChangeInfo.Guid, trans);
// Achievement conversion
for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeAchievements.begin(); it != sObjectMgr->FactionChangeAchievements.end(); ++it)
{
uint32 achiev_alliance = it->first;
uint32 achiev_horde = it->second;
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_BY_ACHIEVEMENT);
stmt->setUInt16(0, uint16(team == TEAM_ALLIANCE ? achiev_alliance : achiev_horde));
stmt->setUInt32(1, lowGuid);
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_ACHIEVEMENT);
stmt->setUInt16(0, uint16(team == TEAM_ALLIANCE ? achiev_alliance : achiev_horde));
stmt->setUInt16(1, uint16(team == TEAM_ALLIANCE ? achiev_horde : achiev_alliance));
stmt->setUInt32(2, lowGuid);
trans->Append(stmt);
}
// Item conversion
for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeItems.begin(); it != sObjectMgr->FactionChangeItems.end(); ++it)
{
uint32 item_alliance = it->first;
uint32 item_horde = it->second;
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_INVENTORY_FACTION_CHANGE);
stmt->setUInt32(0, (team == TEAM_ALLIANCE ? item_alliance : item_horde));
stmt->setUInt32(1, (team == TEAM_ALLIANCE ? item_horde : item_alliance));
stmt->setUInt32(2, lowGuid);
trans->Append(stmt);
}
// Delete all current quests
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_QUESTSTATUS);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
// Quest conversion
for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeQuests.begin(); it != sObjectMgr->FactionChangeQuests.end(); ++it)
{
uint32 quest_alliance = it->first;
uint32 quest_horde = it->second;
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_QUESTSTATUS_REWARDED_BY_QUEST);
stmt->setUInt32(0, lowGuid);
stmt->setUInt32(1, (team == TEAM_ALLIANCE ? quest_alliance : quest_horde));
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_QUESTSTATUS_REWARDED_FACTION_CHANGE);
stmt->setUInt32(0, (team == TEAM_ALLIANCE ? quest_alliance : quest_horde));
stmt->setUInt32(1, (team == TEAM_ALLIANCE ? quest_horde : quest_alliance));
stmt->setUInt32(2, lowGuid);
trans->Append(stmt);
}
// Mark all rewarded quests as "active" (will count for completed quests achievements)
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_QUESTSTATUS_REWARDED_ACTIVE);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
// Disable all old-faction specific quests
{
ObjectMgr::QuestMap const& questTemplates = sObjectMgr->GetQuestTemplates();
for (ObjectMgr::QuestMap::const_iterator iter = questTemplates.begin(); iter != questTemplates.end(); ++iter)
{
Quest const* quest = iter->second;
uint32 newRaceMask = (team == TEAM_ALLIANCE) ? RACEMASK_ALLIANCE : RACEMASK_HORDE;
if (!(quest->GetRequiredRaces() & newRaceMask))
{
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_QUESTSTATUS_REWARDED_ACTIVE_BY_QUEST);
stmt->setUInt32(0, lowGuid);
stmt->setUInt32(1, quest->GetQuestId());
trans->Append(stmt);
}
}
}
// Spell conversion
for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeSpells.begin(); it != sObjectMgr->FactionChangeSpells.end(); ++it)
{
uint32 spell_alliance = it->first;
uint32 spell_horde = it->second;
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SPELL_BY_SPELL);
stmt->setUInt32(0, (team == TEAM_ALLIANCE ? spell_alliance : spell_horde));
stmt->setUInt32(1, lowGuid);
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_SPELL_FACTION_CHANGE);
stmt->setUInt32(0, (team == TEAM_ALLIANCE ? spell_alliance : spell_horde));
stmt->setUInt32(1, (team == TEAM_ALLIANCE ? spell_horde : spell_alliance));
stmt->setUInt32(2, lowGuid);
trans->Append(stmt);
}
// Reputation conversion
for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeReputation.begin(); it != sObjectMgr->FactionChangeReputation.end(); ++it)
{
uint32 reputation_alliance = it->first;
uint32 reputation_horde = it->second;
uint32 newReputation = (team == TEAM_ALLIANCE) ? reputation_alliance : reputation_horde;
uint32 oldReputation = (team == TEAM_ALLIANCE) ? reputation_horde : reputation_alliance;
// select old standing set in db
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_REP_BY_FACTION);
stmt->setUInt32(0, oldReputation);
stmt->setUInt32(1, lowGuid);
if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
{
Field* fields = result->Fetch();
int32 oldDBRep = fields[0].GetInt32();
FactionEntry const* factionEntry = sFactionStore.LookupEntry(oldReputation);
// old base reputation
int32 oldBaseRep = sObjectMgr->GetBaseReputationOf(factionEntry, oldRace, playerClass);
// new base reputation
int32 newBaseRep = sObjectMgr->GetBaseReputationOf(sFactionStore.LookupEntry(newReputation), factionChangeInfo.Race, playerClass);
// final reputation shouldnt change
int32 FinalRep = oldDBRep + oldBaseRep;
int32 newDBRep = FinalRep - newBaseRep;
stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_REP_BY_FACTION);
stmt->setUInt32(0, newReputation);
stmt->setUInt32(1, lowGuid);
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_REP_FACTION_CHANGE);
stmt->setUInt16(0, uint16(newReputation));
stmt->setInt32(1, newDBRep);
stmt->setUInt16(2, uint16(oldReputation));
stmt->setUInt32(3, lowGuid);
trans->Append(stmt);
}
}
// Title conversion
if (!knownTitlesStr.empty())
{
const uint32 ktcount = KNOWN_TITLES_SIZE * 2;
uint32 knownTitles[ktcount];
Tokenizer tokens(knownTitlesStr, ' ', ktcount);
if (tokens.size() != ktcount)
{
SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
return;
}
for (uint32 index = 0; index < ktcount; ++index)
knownTitles[index] = atoul(tokens[index]);
for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeTitles.begin(); it != sObjectMgr->FactionChangeTitles.end(); ++it)
{
uint32 title_alliance = it->first;
uint32 title_horde = it->second;
CharTitlesEntry const* atitleInfo = sCharTitlesStore.LookupEntry(title_alliance);
CharTitlesEntry const* htitleInfo = sCharTitlesStore.LookupEntry(title_horde);
// new team
if (team == TEAM_ALLIANCE)
{
uint32 bitIndex = htitleInfo->bit_index;
uint32 index = bitIndex / 32;
uint32 old_flag = 1 << (bitIndex % 32);
uint32 new_flag = 1 << (atitleInfo->bit_index % 32);
if (knownTitles[index] & old_flag)
{
knownTitles[index] &= ~old_flag;
// use index of the new title
knownTitles[atitleInfo->bit_index / 32] |= new_flag;
}
}
else
{
uint32 bitIndex = atitleInfo->bit_index;
uint32 index = bitIndex / 32;
uint32 old_flag = 1 << (bitIndex % 32);
uint32 new_flag = 1 << (htitleInfo->bit_index % 32);
if (knownTitles[index] & old_flag)
{
knownTitles[index] &= ~old_flag;
// use index of the new title
knownTitles[htitleInfo->bit_index / 32] |= new_flag;
}
}
std::ostringstream ss;
for (uint32 index = 0; index < ktcount; ++index)
ss << knownTitles[index] << ' ';
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_TITLES_FACTION_CHANGE);
stmt->setString(0, ss.str().c_str());
stmt->setUInt32(1, lowGuid);
trans->Append(stmt);
// unset any currently chosen title
stmt = CharacterDatabase.GetPreparedStatement(CHAR_RES_CHAR_TITLES_FACTION_CHANGE);
stmt->setUInt32(0, lowGuid);
trans->Append(stmt);
}
}
}
}
CharacterDatabase.CommitTransaction(trans);
TC_LOG_DEBUG("entities.player", "%s (IP: %s) changed race from %u to %u", GetPlayerInfo().c_str(), GetRemoteAddress().c_str(), oldRace, factionChangeInfo.Race);
SendCharFactionChange(RESPONSE_SUCCESS, factionChangeInfo);
}
void WorldSession::SendCharCreate(ResponseCodes result)
{
WorldPacket data(SMSG_CHAR_CREATE, 1);
data << uint8(result);
SendPacket(&data);
}
void WorldSession::SendCharDelete(ResponseCodes result)
{
WorldPacket data(SMSG_CHAR_DELETE, 1);
data << uint8(result);
SendPacket(&data);
}
void WorldSession::SendCharRename(ResponseCodes result, CharacterRenameInfo const& renameInfo)
{
WorldPacket data(SMSG_CHAR_RENAME, 1 + 8 + renameInfo.Name.size() + 1);
data << uint8(result);
if (result == RESPONSE_SUCCESS)
{
data << renameInfo.Guid;
data << renameInfo.Name;
}
SendPacket(&data);
}
void WorldSession::SendCharCustomize(ResponseCodes result, CharacterCustomizeInfo const& customizeInfo)
{
WorldPacket data(SMSG_CHAR_CUSTOMIZE, 1 + 8 + customizeInfo.Name.size() + 1 + 6);
data << uint8(result);
if (result == RESPONSE_SUCCESS)
{
data << customizeInfo.Guid;
data << customizeInfo.Name;
data << uint8(customizeInfo.Gender);
data << uint8(customizeInfo.Skin);
data << uint8(customizeInfo.Face);
data << uint8(customizeInfo.HairStyle);
data << uint8(customizeInfo.HairColor);
data << uint8(customizeInfo.FacialHair);
}
SendPacket(&data);
}
void WorldSession::SendCharFactionChange(ResponseCodes result, CharacterFactionChangeInfo const& factionChangeInfo)
{
WorldPacket data(SMSG_CHAR_FACTION_CHANGE, 1 + 8 + factionChangeInfo.Name.size() + 1 + 7);
data << uint8(result);
if (result == RESPONSE_SUCCESS)
{
data << factionChangeInfo.Guid;
data << factionChangeInfo.Name;
data << uint8(factionChangeInfo.Gender);
data << uint8(factionChangeInfo.Skin);
data << uint8(factionChangeInfo.Face);
data << uint8(factionChangeInfo.HairStyle);
data << uint8(factionChangeInfo.HairColor);
data << uint8(factionChangeInfo.FacialHair);
data << uint8(factionChangeInfo.Race);
}
SendPacket(&data);
}
void WorldSession::SendSetPlayerDeclinedNamesResult(DeclinedNameResult result, ObjectGuid guid)
{
WorldPacket data(SMSG_SET_PLAYER_DECLINED_NAMES_RESULT, 4 + 8);
data << uint32(result);
data << guid;
SendPacket(&data);
}
void WorldSession::SendBarberShopResult(BarberShopResult result)
{
WorldPacket data(SMSG_BARBER_SHOP_RESULT, 4);
data << uint32(result);
SendPacket(&data);
}
| Java |
# time-of-flight
| Java |
#pragma once
/*
* Copyright (C) 2012 Team XBMC
* http://www.xbmc.org
*
* 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, 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 XBMC; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#include "FileItem.h"
#include "PVRChannelGroup.h"
#include "threads/CriticalSection.h"
namespace PVR
{
/** A container class for channel groups */
class CPVRChannelGroups
{
public:
/*!
* @brief Create a new group container.
* @param bRadio True if this is a container for radio channels, false if it is for tv channels.
*/
CPVRChannelGroups(bool bRadio);
virtual ~CPVRChannelGroups(void);
/*!
* @brief Remove all channels from this group.
*/
void Clear(void);
/*!
* @brief Load this container's contents from the database or PVR clients.
* @return True if it was loaded successfully, false if not.
*/
bool Load(void);
/*!
* @return Amount of groups in this container
*/
int Size(void) const { CSingleLock lock(m_critSection); return m_groups.size(); }
/*!
* @brief Update a group or add it if it's not in here yet.
* @param group The group to update.
* @param bSaveInDb True to save the changes in the db.
* @return True if the group was added or update successfully, false otherwise.
*/
bool Update(const CPVRChannelGroup &group, bool bSaveInDb = false);
/*!
* @brief Called by the add-on callback to add a new group
* @param group The group to add
* @return True when updated, false otherwise
*/
bool UpdateFromClient(const CPVRChannelGroup &group) { return Update(group, false); }
/*!
* @brief Get a channel given it's path
* @param strPath The path to the channel
* @return The channel, or an empty fileitem when not found
*/
CFileItemPtr GetByPath(const CStdString &strPath) const;
/*!
* @brief Get a pointer to a channel group given it's ID.
* @param iGroupId The ID of the group.
* @return The group or NULL if it wasn't found.
*/
CPVRChannelGroupPtr GetById(int iGroupId) const;
/*!
* @brief Get a group given it's name.
* @param strName The name.
* @return The group or NULL if it wan't found.
*/
CPVRChannelGroupPtr GetByName(const CStdString &strName) const;
/*!
* @brief Get the group that contains all channels.
* @return The group that contains all channels.
*/
CPVRChannelGroupPtr GetGroupAll(void) const;
/*!
* @brief Get the list of groups.
* @param results The file list to store the results in.
* @return The amount of items that were added.
*/
int GetGroupList(CFileItemList* results) const;
/*!
* @brief Get the previous group in this container.
* @param group The current group.
* @return The previous group or the group containing all channels if it wasn't found.
*/
CPVRChannelGroupPtr GetPreviousGroup(const CPVRChannelGroup &group) const;
/*!
* @brief Get the next group in this container.
* @param group The current group.
* @return The next group or the group containing all channels if it wasn't found.
*/
CPVRChannelGroupPtr GetNextGroup(const CPVRChannelGroup &group) const;
/*!
* @brief Get the group that is currently selected in the UI.
* @return The selected group.
*/
CPVRChannelGroupPtr GetSelectedGroup(void) const;
/*!
* @brief Change the selected group.
* @param group The group to select.
*/
void SetSelectedGroup(CPVRChannelGroupPtr group);
/*!
* @brief Add a group to this container.
* @param strName The name of the group.
* @return True if the group was added, false otherwise.
*/
bool AddGroup(const CStdString &strName);
/*!
* @brief Delete a group in this container.
* @param group The group to delete.
* @return True if it was deleted successfully, false if not.
*/
bool DeleteGroup(const CPVRChannelGroup &group);
/*!
* @brief Remove a channel from all non-system groups.
* @param channel The channel to remove.
*/
void RemoveFromAllGroups(const CPVRChannel &channel);
/*!
* @brief Persist all changes in channel groups.
* @return True if everything was persisted, false otherwise.
*/
bool PersistAll(void);
/*!
* @return True when this container contains radio groups, false otherwise
*/
bool IsRadio(void) const { return m_bRadio; }
/*!
* @brief Call by a guiwindow/dialog to add the groups to a control
* @param iWindowId The window to add the groups to.
* @param iControlId The control to add the groups to
*/
void FillGroupsGUI(int iWindowId, int iControlId) const;
/*!
* @brief Update the contents of the groups in this container.
* @param bChannelsOnly Set to true to only update channels, not the groups themselves.
* @return True if the update was successful, false otherwise.
*/
bool Update(bool bChannelsOnly = false);
private:
bool UpdateGroupsEntries(const CPVRChannelGroups &groups);
bool LoadUserDefinedChannelGroups(void);
bool GetGroupsFromClients(void);
bool m_bRadio; /*!< true if this is a container for radio channels, false if it is for tv channels */
CPVRChannelGroupPtr m_selectedGroup; /*!< the group that's currently selected in the UI */
std::vector<CPVRChannelGroupPtr> m_groups; /*!< the groups in this container */
CCriticalSection m_critSection;
};
}
| Java |
/*
* Copyright (C) 2008-2011 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#include "Log.h"
#include "ObjectAccessor.h"
#include "CreatureAI.h"
#include "ObjectMgr.h"
#include "TemporarySummon.h"
TempSummon::TempSummon(SummonPropertiesEntry const *properties, Unit *owner) :
Creature(), m_Properties(properties), m_type(TEMPSUMMON_MANUAL_DESPAWN),
m_timer(0), m_lifetime(0)
{
m_summonerGUID = owner ? owner->GetGUID() : 0;
m_unitTypeMask |= UNIT_MASK_SUMMON;
}
Unit* TempSummon::GetSummoner() const
{
return m_summonerGUID ? ObjectAccessor::GetUnit(*this, m_summonerGUID) : NULL;
}
void TempSummon::Update(uint32 diff)
{
Creature::Update(diff);
if (m_deathState == DEAD)
{
UnSummon();
return;
}
switch(m_type)
{
case TEMPSUMMON_MANUAL_DESPAWN:
break;
case TEMPSUMMON_TIMED_DESPAWN:
{
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= diff;
break;
}
case TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT:
{
if (!isInCombat())
{
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
break;
}
case TEMPSUMMON_CORPSE_TIMED_DESPAWN:
{
if (m_deathState == CORPSE)
{
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= diff;
}
break;
}
case TEMPSUMMON_CORPSE_DESPAWN:
{
// if m_deathState is DEAD, CORPSE was skipped
if (m_deathState == CORPSE || m_deathState == DEAD)
{
UnSummon();
return;
}
break;
}
case TEMPSUMMON_DEAD_DESPAWN:
{
if (m_deathState == DEAD)
{
UnSummon();
return;
}
break;
}
case TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN:
{
// if m_deathState is DEAD, CORPSE was skipped
if (m_deathState == CORPSE || m_deathState == DEAD)
{
UnSummon();
return;
}
if (!isInCombat())
{
if (m_timer <= diff)
{
UnSummon();
return;
}
else
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
break;
}
case TEMPSUMMON_TIMED_OR_DEAD_DESPAWN:
{
// if m_deathState is DEAD, CORPSE was skipped
if (m_deathState == DEAD)
{
UnSummon();
return;
}
if (!isInCombat() && isAlive())
{
if (m_timer <= diff)
{
UnSummon();
return;
}
else
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
break;
}
default:
UnSummon();
sLog->outError("Temporary summoned creature (entry: %u) have unknown type %u of ", GetEntry(), m_type);
break;
}
}
void TempSummon::InitStats(uint32 duration)
{
ASSERT(!isPet());
m_timer = duration;
m_lifetime = duration;
if (m_type == TEMPSUMMON_MANUAL_DESPAWN)
m_type = (duration == 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_DESPAWN;
Unit *owner = GetSummoner();
if (owner && isTrigger() && m_spells[0])
{
setFaction(owner->getFaction());
SetLevel(owner->getLevel());
if (owner->GetTypeId() == TYPEID_PLAYER)
m_ControlledByPlayer = true;
}
if (!m_Properties)
return;
if (owner)
{
if (uint32 slot = m_Properties->Slot)
{
if (owner->m_SummonSlot[slot] && owner->m_SummonSlot[slot] != GetGUID())
{
Creature *oldSummon = GetMap()->GetCreature(owner->m_SummonSlot[slot]);
if (oldSummon && oldSummon->isSummon())
oldSummon->ToTempSummon()->UnSummon();
}
owner->m_SummonSlot[slot] = GetGUID();
}
}
if (m_Properties->Faction)
setFaction(m_Properties->Faction);
else if (IsVehicle()) // properties should be vehicle
setFaction(owner->getFaction());
}
void TempSummon::InitSummon()
{
Unit* owner = GetSummoner();
if (owner)
{
if (owner->GetTypeId() == TYPEID_UNIT && owner->ToCreature()->IsAIEnabled)
owner->ToCreature()->AI()->JustSummoned(this);
if (IsAIEnabled)
AI()->IsSummonedBy(owner);
}
}
void TempSummon::SetTempSummonType(TempSummonType type)
{
m_type = type;
}
void TempSummon::UnSummon(uint32 msTime)
{
if (msTime)
{
ForcedUnsummonDelayEvent *pEvent = new ForcedUnsummonDelayEvent(*this);
m_Events.AddEvent(pEvent, m_Events.CalculateTime(msTime));
return;
}
//ASSERT(!isPet());
if (isPet())
{
((Pet*)this)->Remove(PET_SAVE_NOT_IN_SLOT);
ASSERT(!IsInWorld());
return;
}
Unit* owner = GetSummoner();
if (owner && owner->GetTypeId() == TYPEID_UNIT && owner->ToCreature()->IsAIEnabled)
owner->ToCreature()->AI()->SummonedCreatureDespawn(this);
if (owner &&
owner->GetTypeId() == TYPEID_PLAYER &&
((Player*)owner)->HaveBot() &&
((Player*)owner)->GetBot()->GetGUID()==this->GetGUID() &&
this->isDead()) { // dont unsummon corpse if a bot
return;
}
AddObjectToRemoveList();
}
bool ForcedUnsummonDelayEvent::Execute(uint64 /*e_time*/, uint32 /*p_time*/)
{
m_owner.UnSummon();
return true;
}
void TempSummon::RemoveFromWorld()
{
if (!IsInWorld())
return;
if (m_Properties)
if (uint32 slot = m_Properties->Slot)
if (Unit* owner = GetSummoner())
if (owner->m_SummonSlot[slot] == GetGUID())
owner->m_SummonSlot[slot] = 0;
//if (GetOwnerGUID())
// sLog->outError("Unit %u has owner guid when removed from world", GetEntry());
Creature::RemoveFromWorld();
}
Minion::Minion(SummonPropertiesEntry const *properties, Unit *owner) : TempSummon(properties, owner)
, m_owner(owner)
{
ASSERT(m_owner);
m_unitTypeMask |= UNIT_MASK_MINION;
m_followAngle = PET_FOLLOW_ANGLE;
}
void Minion::InitStats(uint32 duration)
{
TempSummon::InitStats(duration);
SetReactState(REACT_PASSIVE);
SetCreatorGUID(m_owner->GetGUID());
setFaction(m_owner->getFaction());
m_owner->SetMinion(this, true);
}
void Minion::RemoveFromWorld()
{
if (!IsInWorld())
return;
m_owner->SetMinion(this, false);
TempSummon::RemoveFromWorld();
}
bool Minion::IsGuardianPet() const
{
return isPet() || (m_Properties && m_Properties->Category == SUMMON_CATEGORY_PET);
}
Guardian::Guardian(SummonPropertiesEntry const *properties, Unit *owner) : Minion(properties, owner)
, m_bonusSpellDamage(0)
{
memset(m_statFromOwner, 0, sizeof(float)*MAX_STATS);
m_unitTypeMask |= UNIT_MASK_GUARDIAN;
if (properties && properties->Type == SUMMON_TYPE_PET)
{
m_unitTypeMask |= UNIT_MASK_CONTROLABLE_GUARDIAN;
InitCharmInfo();
}
}
void Guardian::InitStats(uint32 duration)
{
Minion::InitStats(duration);
InitStatsForLevel(m_owner->getLevel());
if (m_owner->GetTypeId() == TYPEID_PLAYER && HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN))
m_charmInfo->InitCharmCreateSpells();
SetReactState(REACT_AGGRESSIVE);
}
void Guardian::InitSummon()
{
TempSummon::InitSummon();
if (m_owner->GetTypeId() == TYPEID_PLAYER
&& m_owner->GetMinionGUID() == GetGUID()
&& !m_owner->GetCharmGUID())
m_owner->ToPlayer()->CharmSpellInitialize();
}
Puppet::Puppet(SummonPropertiesEntry const *properties, Unit *owner) : Minion(properties, owner)
{
ASSERT(owner->GetTypeId() == TYPEID_PLAYER);
m_owner = (Player*)owner;
m_unitTypeMask |= UNIT_MASK_PUPPET;
}
void Puppet::InitStats(uint32 duration)
{
Minion::InitStats(duration);
SetLevel(m_owner->getLevel());
SetReactState(REACT_PASSIVE);
}
void Puppet::InitSummon()
{
Minion::InitSummon();
if (!SetCharmedBy(m_owner, CHARM_TYPE_POSSESS))
ASSERT(false);
}
void Puppet::Update(uint32 time)
{
Minion::Update(time);
//check if caster is channelling?
if (IsInWorld())
{
if (!isAlive())
{
UnSummon();
// TODO: why long distance .die does not remove it
}
}
}
void Puppet::RemoveFromWorld()
{
if (!IsInWorld())
return;
RemoveCharmedBy(NULL);
Minion::RemoveFromWorld();
}
| Java |
CREATE TABLE `wp_term_taxonomy` (
`term_taxonomy_id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`term_id` bigint(20) unsigned NOT NULL DEFAULT '0',
`taxonomy` varchar(32) NOT NULL DEFAULT '',
`description` longtext NOT NULL,
`parent` bigint(20) unsigned NOT NULL DEFAULT '0',
`count` bigint(20) NOT NULL DEFAULT '0',
PRIMARY KEY (`term_taxonomy_id`),
UNIQUE KEY `term_id_taxonomy` (`term_id`,`taxonomy`),
KEY `taxonomy` (`taxonomy`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 | Java |
/*! jQuery UI - v1.8.20 - 2012-04-30
* https://github.com/jquery/jquery-ui
* Includes: jquery.effects.transfer.js
* Copyright (c) 2012 AUTHORS.txt; Licensed MIT, GPL */(function(a,b){a.effects.transfer=function(b){return this.queue(function(){var c=a(this),d=a(b.options.to),e=d.offset(),f={top:e.top,left:e.left,height:d.innerHeight(),width:d.innerWidth()},g=c.offset(),h=a('<div class="ui-effects-transfer"></div>').appendTo(document.body).addClass(b.options.className).css({top:g.top,left:g.left,height:c.innerHeight(),width:c.innerWidth(),position:"absolute"}).animate(f,b.duration,b.options.easing,function(){h.remove(),b.callback&&b.callback.apply(c[0],arguments),c.dequeue()})})}})(jQuery); | Java |
/*
** Zabbix
** Copyright (C) 2001-2018 Zabbix SIA
**
** 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**/
#ifndef ZABBIX_HISTORY_H
#define ZABBIX_HISTORY_H
#define ZBX_HISTORY_IFACE_SQL 0
#define ZBX_HISTORY_IFACE_ELASTIC 1
typedef struct zbx_history_iface zbx_history_iface_t;
typedef void (*zbx_history_destroy_func_t)(struct zbx_history_iface *hist);
typedef int (*zbx_history_add_values_func_t)(struct zbx_history_iface *hist, const zbx_vector_ptr_t *history);
typedef int (*zbx_history_get_values_func_t)(struct zbx_history_iface *hist, zbx_uint64_t itemid, int start,
int count, int end, zbx_vector_history_record_t *values);
typedef void (*zbx_history_flush_func_t)(struct zbx_history_iface *hist);
struct zbx_history_iface
{
unsigned char value_type;
unsigned char requires_trends;
void *data;
zbx_history_destroy_func_t destroy;
zbx_history_add_values_func_t add_values;
zbx_history_get_values_func_t get_values;
zbx_history_flush_func_t flush;
};
/* SQL hist */
int zbx_history_sql_init(zbx_history_iface_t *hist, unsigned char value_type, char **error);
/* elastic hist */
int zbx_history_elastic_init(zbx_history_iface_t *hist, unsigned char value_type, char **error);
#endif
| Java |
package com.orange.documentare.core.comp.clustering.tasksservice;
/*
* Copyright (c) 2016 Orange
*
* Authors: Christophe Maldivi & Joel Gardes
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
import com.orange.documentare.core.comp.clustering.graph.ClusteringParameters;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.fest.assertions.Assertions;
import org.junit.After;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
@Slf4j
public class ClusteringTasksServiceTest {
private static final int NB_TASKS = 4 * 10;
private static final String CLUSTERING_TASK_FILE_PREFIX = "clustering_tasks_";
private static final String STRIPPED_CLUSTERING_JSON = "stripped_clustering.json";
private static final String NOT_STRIPPED_CLUSTERING_JSON = "not_stripped_clustering.json";
private final ClusteringTasksService tasksHandler = ClusteringTasksService.instance();
private final ClusteringParameters parameters = ClusteringParameters.builder().acut().qcut().build();
@After
public void cleanup() {
FileUtils.deleteQuietly(new File(STRIPPED_CLUSTERING_JSON));
FileUtils.deleteQuietly(new File(NOT_STRIPPED_CLUSTERING_JSON));
}
@Test
public void runSeveralDistinctTasks() throws IOException, InterruptedException {
// given
String refJson1 = FileUtils.readFileToString(new File(getClass().getResource("/clusteringtasks/latin1_clustering.ref.json").getFile()));
String refJson2 = FileUtils.readFileToString(new File(getClass().getResource("/clusteringtasks/latin2_clustering.ref.json").getFile()));
String refJson3 = FileUtils.readFileToString(new File(getClass().getResource("/clusteringtasks/latin3_clustering.ref.json").getFile()));
String refJson4 = FileUtils.readFileToString(new File(getClass().getResource("/clusteringtasks/latin4_clustering.ref.json").getFile()));
File segFile1 = new File(getClass().getResource("/clusteringtasks/latin1_segmentation.json").getFile());
File segFile2 = new File(getClass().getResource("/clusteringtasks/latin2_segmentation.json").getFile());
File segFile3 = new File(getClass().getResource("/clusteringtasks/latin3_segmentation.json").getFile());
File segFile4 = new File(getClass().getResource("/clusteringtasks/latin4_segmentation.json").getFile());
String[] outputFilenames = new String[NB_TASKS];
ClusteringTask[] clusteringTasks = new ClusteringTask[NB_TASKS];
for (int i = 0; i < NB_TASKS; i++) {
outputFilenames[i] = CLUSTERING_TASK_FILE_PREFIX + i + ".json";
}
for (int i = 0; i < NB_TASKS/4; i++) {
clusteringTasks[i * 4] = ClusteringTask.builder()
.inputFilename(segFile1.getAbsolutePath())
.outputFilename(outputFilenames[i * 4])
.clusteringParameters(parameters)
.build();
clusteringTasks[i * 4 + 1] = ClusteringTask.builder()
.inputFilename(segFile2.getAbsolutePath())
.outputFilename(outputFilenames[i * 4 + 1])
.clusteringParameters(parameters)
.build();
clusteringTasks[i * 4 + 2] = ClusteringTask.builder()
.inputFilename(segFile3.getAbsolutePath())
.outputFilename(outputFilenames[i * 4 + 2])
.clusteringParameters(parameters)
.build();
clusteringTasks[i * 4 + 3] = ClusteringTask.builder()
.inputFilename(segFile4.getAbsolutePath())
.outputFilename(outputFilenames[i * 4 + 3])
.clusteringParameters(parameters)
.build();
}
// when
for (int i = 0; i < NB_TASKS; i++) {
tasksHandler.addNewTask(clusteringTasks[i]);
Thread.sleep(200);
log.info(tasksHandler.tasksDescription().toString());
}
tasksHandler.waitForAllTasksDone();
String[] outputJsons = new String[NB_TASKS];
for (int i = 0; i < NB_TASKS; i++) {
outputJsons[i] = FileUtils.readFileToString(new File(outputFilenames[i]));
}
// then
for (int i = 0; i < NB_TASKS/4; i++) {
Assertions.assertThat(outputJsons[i * 4]).isEqualTo(refJson1);
Assertions.assertThat(outputJsons[i * 4 + 1]).isEqualTo(refJson2);
Assertions.assertThat(outputJsons[i * 4 + 2]).isEqualTo(refJson3);
Assertions.assertThat(outputJsons[i * 4 + 3]).isEqualTo(refJson4);
}
Arrays.stream(outputFilenames)
.forEach(f -> FileUtils.deleteQuietly(new File(f)));
}
@Test
public void saveStrippedOutput() throws IOException, InterruptedException {
// given
File ref = new File(getClass().getResource("/clusteringtasks/stripped_clustering.ref.json").getFile());
String jsonRef = FileUtils.readFileToString(ref);
String strippedFilename = STRIPPED_CLUSTERING_JSON;
File strippedFile = new File(strippedFilename);
strippedFile.delete();
File segFile = new File(getClass().getResource("/clusteringtasks/latin1_segmentation.json").getFile());
String outputFilename = NOT_STRIPPED_CLUSTERING_JSON;
ClusteringTask task = ClusteringTask.builder()
.inputFilename(segFile.getAbsolutePath())
.outputFilename(outputFilename)
.clusteringParameters(parameters)
.strippedOutputFilename(strippedFilename)
.build();
// when
tasksHandler.addNewTask(task);
tasksHandler.waitForAllTasksDone();
// then
String strippedJson = FileUtils.readFileToString(strippedFile);
Assertions.assertThat(strippedFile).exists();
Assertions.assertThat(strippedJson).isEqualTo(jsonRef);
}
}
| Java |
.head_title {
text-align: center;
font-size: 20px;
color:#002529;
font-weight: 400;
position:relative;
}
.head_title:after{content: ''; position: absolute;left: 0;top:30px; background:#cacaca; width: 100%;height: 1px;
-webkit-transform: scaleY(0.5);transform: scaleY(0.5);-webkit-transform-origin: 0 0;transform-origin: 0 0; }
.weui-search-bar,.weui-search-bar__form{background-color:#fff;}
.weui-search-bar__label{text-align: left;margin:0 10px;}
.weui-search-bar:before{border-top:none;}
.weui-search-bar:after{border-bottom:none;}
.swiper-container {
width: 100%;
height: 100%;
}
.swiper-container img{width:100%;height:100%;}
.btn_libao{margin:10px 36px; height: auto; overflow: hidden;}
.btn_libao img{width:100%; height:100%; max-width: 100%; }
.bar_square{margin:10px 0; }
.bar_square:before, .bar_square:after,.bar_square .weui-grid:before{border:none;}
.bar_square .weui-grid__icon{width:45px;height: 50px;}
.bar_square .weui-footer, .weui-grid__label{font-size:16px;}
.song_left{ width:50%; padding-right:5px;}
.song_left img{width:100%; max-width: 100%;}
.song_right{width:50%;}
.song_right img{width:100%; max-width: 100%;}
.demos-title {
text-align: center;
font-size:30px;
color: #2b2b2b;
font-weight: 400;
margin: 0 15%;
}
.demos-sub-title {
text-align: center;
color: #2b2b2b;
font-size: 14px;
}
.demos-header {
position:relative;
margin:25px 0;
}
.demos_right_ico{position:absolute; right:25px;top:30px;}
.demos_right_ico:after{
content: " ";
display: inline-block;
height: 12px;
width: 12px;
border-width: 2px 2px 0 0;
border-color: #c8c8cd;
border-style: solid;
-webkit-transform: matrix(.71,.71,-.71,.71,0,0);
transform: matrix(.71,.71,-.71,.71,0,0);
position: relative;
position: absolute;
right: 2px;
}
.flavor{padding-bottom:5px;}
.flavor .weui-grid__icon{width:100%;height: 100%;}
/*热卖精选*/
.hot_buy{margin:20px 0 80px; height: auto; overflow: hidden; padding:0 2%;}
.hot_buy li{float: left; list-style: none; width:48%;margin:0 1%; text-align: center; margin-bottom:20px;}
.hot_buy img{width:100%;height:100%;}
.hot_buy .p1{color: #222222; font-size:16px; font-weight: bolder;}
.hot_buy .p2{color: #494949; font-size:14px;}
.hot_buy .p3{color: #f4392d; font-size:16px;}
.weui-tabbar{position:fixed;}
.weui-tabbar__item .weui-tabbar__label{color:#252525;}
.weui-tabbar__item.active .weui-tabbar__label{color:#ff2d2d;}
.active i{color:#ff2d2d;}
/**新品上市*/
.news_list li{
box-sizing: border-box;
border:1px solid #eaeaea;
text-align:left;
height: auto;
overflow: hidden;
}
.news_list li p{padding:0 5px;line-height: 26px;}
.news_list li .p2{color: #666666;}
.news_list li .p3 span{color:#b8b8b8; text-decoration: line-through; padding-left:15px;}
.news_list li .p4{font-size:12px; color:#b8b8b8; padding:5px 5px;}
/**类型*/
.type-tab{border-top:1px solid #eee;}
.type_left{float: left;width:30%;position:inherit;display: block; background:#fff;}
.type_left .weui-navbar__item{width:100%;height: auto;overflow: hidden;}
.type_left .weui-navbar__item:after{border-right:none;}
.type_left:after{border-bottom:none;}
.type_right{float:left; width:70%; border-left: 1px solid #eee;min-height: 500px;}
.weui-navbar+.type_right{padding-top:0;}
.type_right .rqtj_list .p_title{font-size:13px; color: #636363;}
.type_right .rqtj_list .p_price{font-size:13px; color:red; text-align: center;}
.pinpai_list li{
list-style: none;
width:31%;
box-sizing: border-box;
padding:0 5px;
border:1px solid #eee;
border-radius: 2px;
}
.pinpai_list li .p_title{text-align: center; font-size:13px; color: #636363;margin-bottom:5px;}
.type_renqun{width:80%;margin:0 10%;}
.type_renqun li{list-style: none; width:100%;}
.type_renqun li img{width:100%;height: 100%;}
.type_right .hot_buy{margin:0 0 80px;}
.type_right .p_biaoti{text-align: center; margin:15px 0; color: #adadad;font-size:13px;}
.type_right .p_biaoti span{color: #eaeaea;}
/**个人中心*/
.nav_info{
background-color:#ec3e36; height:120px;width:100%;
}
.nav_info img{width:50px;height: 50px; border-radius: 50%; border:2px solid #fff; float: left; margin:20px ;}
.nav_info p{color: #fff; font-size: 18px; padding-top:40px;}
.cells_setall{padding-bottom:10px;font-size:16px;}
.cells_setall:before{border:none;}
.weui-cells:after{bottom:1px;}
.user_navlist{text-align: center; color:#938e8e;margin:15px 0}
.user_navlist i{color:#938e8e}
.div_gray{width:100%;height:10px; background: #eeeeee;}
.user_list p{color: #444;}
.user_list:before{border:none;}
/*three.html 详细信息*/
.three_pageinfo{padding:10px;}
.three_pageinfo .p1{color: #373b41;font-size:18px;}
.three_pageinfo .p1 span{background: #66d8d6;display:inline-block;font-size:14px; padding:1px 5px;border-radius: 5px; margin-left: 10px; color:#fff;}
.three_pageinfo .p2{color: #b8b8b8;font-size:16px;margin-top:5px;}
.three_pageinfo .p3{color: #f44236;font-size:18px;font-weight: bolder; margin-top:10px;}
.three_pageinfo .p3 span{display: inline-block;text-decoration: line-through;color: #b8b8b8;margin-left:15px;}
.three_pageinfo .p4{color: #f44236;font-size:16px;border-top:1px solid #eee;margin-top:10px;padding:5px 0;}
.three_guige{margin:10px 0;}
.three_guige p{color:#b8b8b8;font-size:14px;}
.three_guige p span{color:#000000;font-size:14px;margin-left:15px;}
.three_guige:before,.three_guige:after{border:None;}
.three_guige .weui-cell_access .weui-cell__ft:after{border-color:#000000;width:10px;height: 10px;border-width: 1px 1px 0 0;}
.evaluate .weui-cell__bd{color:#b8b8b8}
.evaluate .weui-cell__bd span{display: inline-block;margin-left: 10px; color:#373b41}
.evaluate .weui-cell__bd label{color:red;}
.three_imglist{margin:10px 0 80px; padding:0 10px;}
.three_imglist p{color:#b8b8b8;margin:5px 0;}
.three_imglist img{width:100%;height: 100%;}
.placeholder {
margin: 5px 10px;
padding: 0 20px;
text-align: center;
color: #cfcfcf;
}
.buy_button{display: block; background: #ff3939}
.buy_button .weui-tabbar__item .weui-tabbar__label{color:#fff;font-size:16px;padding-top:10px;}
.buy_wintop{margin:20px 0; height: auto;overflow: hidden;}
.buy_wintop img{float: left; width:50px; height: 50px;margin-left:20px;}
.buy_wintop .div_right{float: left;font-size:14px;margin-left:15px;}
.buy_wintop .p2{color:#f44236;font-size:12px;font-weight: bolder;}
.buy_wintop .p3{color:#b8b8b8;font-size:12px;}
.buy_winmiddle{padding:10px 20px;width:100%;height: auto; overflow: hidden;color: #000;}
.buy_winmiddle span{display: inline-block;margin:10px 5px 0; border-radius: 3px; border:1px solid #666; width:40%;text-align: center;}
.buy_winmiddle .active{border:1px solid #f44236;color: #f44236;}
.buy_bottom p{float: left;}
.weui-actionsheet__title{height: auto;overflow: hidden; text-align: left;padding: 0;}
.weui-actionsheet__action{display: none;}
.gw_num{float:left; margin-left:43%;border: 1px solid #dbdbdb; line-height: 26px;overflow: hidden;}
.gw_num em{display: block;height: 26px;width: 26px;float:left;color: #7A7979;border-right: 1px solid #dbdbdb;text-align: center;cursor: pointer;}
.gw_num .num{display: block;float: left;text-align: center;width: 52px;font-style: normal;font-size: 14px;line-height: 26px;border: 0;}
.gw_num em.add{float: right;border-right:0;border-left: 1px solid #dbdbdb;}
| Java |
#!/bin/bash
if [ -z $1 ]
then
exit 0
fi
ip=$1
rules=$2
trunk=$3
access=$4
general_rules='/etc/isida/isida.conf'
get_uplink=`grep 'uplink' $general_rules | cut -d= -f2 | sed -e s/%ip/$ip/`
ism_vlanid=`grep 'ism_vlanid' $general_rules | cut -d= -f2`
port_count=`echo $5 | sed -e s/://`
args=''
count=0
enum_pars=`cat $rules | grep -v '#' | grep '\.x\.' | cut -d. -f1 | uniq`
raw_fix='/tmp/'`date +%s%N`'-fix'
not_access=`/usr/local/sbin/invert_string_interval.sh $access $port_count`
not_trunk=`/usr/local/sbin/invert_string_interval.sh $trunk $port_count`
# Traffic control
traf_control_thold=`grep traffic_control_bcast_threshold $rules | cut -d= -f2`
traffic_control_trap="config traffic control_trap both"
access_ports="`/usr/local/sbin/interval_to_string.sh $access`"
not_access_ports="`/usr/local/sbin/interval_to_string.sh $not_access`"
traffic_control_string=""
for i in $access_ports
do
traffic_control_string=$traffic_control_string"\nconfig traffic control $i broadcast enable multicast enable unicast disable action drop broadcast_threshold $traf_control_thold multicast_threshold 128 unicast_threshold 131072 countdown 0 time_interval 5"
done
for i in $not_access_ports
do
traffic_control_string=$traffic_control_string"\nconfig traffic control $i broadcast disable multicast disable unicast disable action drop broadcast_threshold $traf_control_thold multicast_threshold 128 unicast_threshold 131072 countdown 0 time_interval 5"
done
# LBD
if [ "`grep lbd_state $rules | cut -d= -f2`" = "enable" ]
then
lbd_state="enable loopdetect"
else
lbd_state="disable loopdetect"
fi
lbd_trap="config loopdetect trap `grep lbd_trap $rules | cut -d= -f2`"
lbd_on=""
for i in $access_ports
do
lbd_on=$lbd_on"\nconfig loopdetect ports $i state enable"
done
lbd_off=""
for i in $not_access_ports
do
lbd_off=$lbd_off"\nconfig loopdetect ports $i state disable"
done
#lbd_off="config loopdetect ports $not_access state disabled"
# Safeguard
sg_state=`grep safeguard_state $rules | cut -d= -f2`
sg_rise=`grep safeguard_rising $rules | cut -d= -f2`
sg_fall=`grep safeguard_falling $rules | cut -d= -f2`
if [ "`grep safeguard_trap $rules | cut -d= -f2`" = "yes" ]
then
sg_trap="enable"
else
sg_trap="disable"
fi
safeguard_string="config safeguard_engine state $sg_state utilization rising $sg_rise falling $sg_fall trap_log $sg_trap mode fuzzy"
# Other
snmp_traps="enable snmp traps\nenable snmp authenticate traps"
dhcp_local_relay="disable dhcp_local_relay"
dhcp_snooping="disable address_binding dhcp_snoop"
impb_acl_mode="disable address_binding acl_mode"
dhcp_screening="config filter dhcp_server ports all state disable\nconfig filter dhcp_server ports $access state enable"
netbios_filter="config filter netbios all state disable\nconfig filter netbios $access state enable"
impb_trap="enable address_binding trap_log"
cpu_interface_filtering="enable cpu_interface_filtering"
arp_aging_time="config arp_aging time `grep arp_aging_time $rules | cut -d= -f2`"
igmp_snooping="enable igmp_snooping"
link_trap="enable snmp linkchange_traps\nconfig snmp linkchange_traps ports 1-28 enable"
# SNTP
sntp_addr1=`grep sntp_primary $rules | cut -d= -f2 | awk -F:: '{print $1}'`
sntp_addr2=`grep sntp_primary $rules | cut -d= -f2 | awk -F:: '{print $2}'`
sntp_string="enable sntp\nconfig sntp primary $sntp_addr1 secondary $sntp_addr2 poll-interval 720\nconfig sntp primary $sntp_addr2 secondary $sntp_addr1"
# IGMP acc auth
igmp_acc_auth_enabled="config igmp access_authentication ports $access state enable"
igmp_acc_auth_disabled="config igmp access_authentication ports $not_access state disable"
# Limited mcast
range1="config limited_multicast_addr ports $access add profile_id 1\nconfig limited_multicast_addr ports $not_access delete profile_id 1"
range2="config limited_multicast_addr ports $access add profile_id 2\nconfig limited_multicast_addr ports $not_access delete profile_id 2"
range3="config limited_multicast_addr ports $access add profile_id 3\nconfig limited_multicast_addr ports $not_access delete profile_id 3"
range4="config limited_multicast_addr ports $access add profile_id 4\nconfig limited_multicast_addr ports $not_access delete profile_id 4"
range5="config limited_multicast_addr ports $access add profile_id 5\nconfig limited_multicast_addr ports $not_access delete profile_id 5"
limited_access="config limited_multicast_addr ports $access access permit"
limited_deny="config limited_multicast_addr ports $trunk access deny"
# SYSLOG
syslog_ip=`grep 'syslog_host.x.ip' $rules | cut -d= -f2`
#syslog_severity=`grep 'syslog_host.x.severity' $rules | cut -d= -f2`
syslog_facility=`grep 'syslog_host.x.facility' $rules | cut -d= -f2`
syslog_state=`grep 'syslog_host.x.state' $rules | cut -d= -f2`
syslog_del="delete syslog host 2"
syslog_add="create syslog host 2 ipaddress $syslog_ip severity debug facility $syslog_facility state $syslog_state"
syslog_enabled="enable_syslog"
# SNMP
snmp_ip=`grep 'snmp_host.x.ip' $rules | cut -d= -f2`
snmp_community=`grep 'snmp_host.x.community' $rules | cut -d= -f2`
snmp_del="delete snmp host $snmp_ip\ndelete snmp host 192.168.1.120"
snmp_add="create snmp host $snmp_ip v2c $snmp_community"
# RADIUS
radius_ip=`grep 'radius.x.ip' $rules | cut -d= -f2`
radius_key=`grep 'radius.x.key' $rules | cut -d= -f2`
radius_auth=`grep 'radius.x.auth' $rules | cut -d= -f2`
radius_acct=`grep 'radius.x.acct' $rules | cut -d= -f2`
radius_retransmit=`grep 'radius_retransmit' $rules | cut -d= -f2`
radius_timeout=`grep 'radius_timeout' $rules | cut -d= -f2`
radius_del="config radius delete 1"
radius_add="config radius add 1 $radius_ip key $radius_key auth_port $radius_auth acct_port $radius_acct"
radius_params="config radius 1 timeout $radius_timeout retransmit $radius_retransmit"
for i in $@
do
case $i in
"traffic_control_trap") echo -e "$traffic_control_string" >> $raw_fix;;
"traffic_control_bcast") echo -e "$traffic_control_string" >> $raw_fix;;
"traffic_control_mcast") echo -e "$traffic_control_string" >> $raw_fix;;
"traffic_control_bcast_threshold") echo -e "$traffic_control_string" >> $raw_fix;;
"traffic_control_mcast_threshold") echo -e "$traffic_control_string" >> $raw_fix;;
"lbd_state") echo -e "$lbd_state" >> $raw_fix;;
"lbd_on") echo -e "$lbd_on" >> $raw_fix;;
"lbd_off") echo -e "$lbd_off" >> $raw_fix;;
"lbd_trap") echo -e "$lbd_trap" >> $raw_fix;;
"safeguard_state") echo -e "$safeguard_string" >> $raw_fix;;
"safeguard_trap") echo -e "$safeguard_string" >> $raw_fix;;
"safeguard_rising") echo -e "$safeguard_string" >> $raw_fix;;
"safeguard_falling") echo -e "$safeguard_string" >> $raw_fix;;
"snmp_traps") echo -e "$snmp_traps" >> $raw_fix;;
"dhcp_local_relay") echo -e "$dhcp_local_relay" >> $raw_fix;;
"dhcp_snooping") echo -e "$dhcp_snooping" >> $raw_fix;;
"impb_acl_mode") echo -e "$impb_acl_mode" >> $raw_fix;;
"dhcp_screening") echo -e "$dhcp_screening" >> $raw_fix;;
"netbios_filter") echo -e "$netbios_filter" >> $raw_fix;;
"impb_trap") echo -e "$impb_trap" >> $raw_fix;;
"cpu_interface_filtering") echo -e "$cpu_interface_filtering" >> $raw_fixing;;
"arp_aging_time") echo -e "$arp_aging_time" >> $raw_fix;;
"sntp_state") echo -e "$sntp_string" >> $raw_fix;;
"sntp_primary") echo -e "$sntp_string" >> $raw_fix;;
"sntp_secondary") echo -e "$sntp_string" >> $raw_fix;;
"link_trap") echo -e "$link_trap" >> $raw_fix;;
"mcast_range.iptv1") echo -e "$range1\n$limited_access\n$limited_deny" >> $raw_fix;;
"mcast_range.iptv2") echo -e "$range2\n$limited_access\n$limited_deny" >> $raw_fix;;
"mcast_range.iptv3") echo -e "$range3\n$limited_access\n$limited_deny" >> $raw_fix;;
"mcast_range.iptv4") echo -e "$range4\n$limited_access\n$limited_deny" >> $raw_fix;;
"mcast_range.iptv5") echo -e "$range5\n$limited_access\n$limited_deny" >> $raw_fix;;
"igmp_acc_auth_enabled") echo -e "$igmp_acc_auth_enabled" >> $raw_fix;;
"igmp_acc_auth_disabled") echo -e "$igmp_acc_auth_disabled" >> $raw_fix;;
"syslog_host") echo -e "$syslog_del\n$syslog_add" >> $raw_fix;;
"snmp_host") echo -e "$snmp_del\n$snmp_add" >> $raw_fix;;
"radius") echo -e "$radius_del\n$radius_add\n$radius_params" >> $raw_fix;;
"radius_retransmit") echo -e "$radius_params" >> $raw_fix;;
"radius_timeout") echo -e "$radius_params" >> $raw_fix;;
"igmp_snooping") echo -e "$igmp_snooping" >> $raw_fix;;
"syslog_enabled") echo -e "$syslog_enabled" >> $raw_fix;;
"ism") if [ `/usr/local/sbin/ping_equip.sh $ip` -eq 1 ]
then
ism_prefix='.1.3.6.1.4.1.171.12.64.3.1.1'
ism_name=`snmpget -v2c -c dlread -Ovq $ip $ism_prefix.2.$ism_vlanid | sed -e s/\"//g`
uplink=`$get_uplink`
raw_tagmember=`snmpget -v2c -c dlread -Ovq $ip $ism_prefix.5.$ism_vlanid | sed -e s/\"//g | awk '{print $1 $2 $3 $4}' | xargs -l /usr/local/sbin/portconv.sh`
raw_member=`snmpget -v2c -c dlread -Ovq $ip $ism_prefix.4.$ism_vlanid | sed -e s/\"//g | awk '{print $1 $2 $3 $4}' | xargs -l /usr/local/sbin/portconv.sh`
raw_source=`snmpget -v2c -c dlread -Ovq $ip $ism_prefix.3.$ism_vlanid | sed -e s/\"//g | awk '{print $1 $2 $3 $4}' | xargs -l /usr/local/sbin/portconv.sh`
tagmember=`/usr/local/sbin/string_to_bitmask.sh $raw_tagmember | xargs -l /usr/local/sbin/bitmask_to_interval.sh`
source=`/usr/local/sbin/string_to_bitmask.sh $raw_source | xargs -l /usr/local/sbin/bitmask_to_interval.sh`
echo -e "config igmp_snooping multicast_vlan $ism_name del tag $tagmember" >> $raw_fix
echo -e "config igmp_snooping multicast_vlan $ism_name del source $source" >> $raw_fix
detailed_trunk=`/usr/local/sbin/interval_to_string.sh $trunk`
del_member_raw=''
for i in $detailed_trunk
do
if [ "`echo $raw_member | grep $i`" ]
then
del_member_raw=$del_member_raw" $i"
fi
done
if [ -n "$del_member_raw" ]
then
del_member=`/usr/local/sbin/string_to_bitmask.sh $del_member_raw | xargs -l /usr/local/sbin/bitmask_to_interval.sh`
echo -e "config igmp_snooping multicast_vlan $ism_name del member $del_member" >> $raw_fix
fi
new_source=$uplink
new_tagmember=`echo $detailed_trunk | sed -e s/$uplink// | xargs -l /usr/local/sbin/string_to_bitmask.sh | xargs -l /usr/local/sbin/bitmask_to_interval.sh`
echo -e "config igmp_snooping multicast_vlan $ism_name add source $new_source" >> $raw_fix
echo -e "config igmp_snooping multicast_vlan $ism_name add tag $new_tagmember" >> $raw_fix
fi;;
esac
done
fix_cmd='/tmp/'`date +%s%N`'_fix'
if [ -s $raw_fix ]
then
echo "save" >> $raw_fix
fi
cat $raw_fix | uniq
rm -f $rules $raw_fix
| Java |
/*
Colorbox Core Style:
The following CSS is consistent between example themes and should not be altered.
*/
#colorbox, #cboxOverlay, #cboxWrapper{position:absolute; top:0; left:0; z-index:9999; overflow:hidden;}
#cboxWrapper {max-width:none;}
#cboxOverlay{position:fixed; width:100%; height:100%;}
#cboxMiddleLeft, #cboxBottomLeft{clear:left;}
#cboxContent{position:relative;}
#cboxLoadedContent{overflow:auto; -webkit-overflow-scrolling: touch;}
#cboxTitle{margin:0;}
#cboxLoadingOverlay, #cboxLoadingGraphic{position:absolute; top:0; left:0; width:100%; height:100%;}
#cboxPrevious, #cboxNext, #cboxClose, #cboxSlideshow{cursor:pointer;}
.cboxPhoto{float:left; margin:auto; border:0; display:block; max-width:none; -ms-interpolation-mode:bicubic;}
.cboxIframe{width:100%; height:100%; display:block; border:0;}
#colorbox, #cboxContent, #cboxLoadedContent{box-sizing:content-box; -moz-box-sizing:content-box; -webkit-box-sizing:content-box;}
/*
User Style:
Change the following styles to modify the appearance of Colorbox. They are
ordered & tabbed in a way that represents the nesting of the generated HTML.
*/
#colorbox{outline:0;}
#cboxTopLeft{width:21px; height:21px; background:url(images/controls.png) no-repeat -101px 0;}
#cboxTopRight{width:21px; height:21px; background:url(images/controls.png) no-repeat -130px 0;}
#cboxBottomLeft{width:21px; height:21px; background:url(images/controls.png) no-repeat -101px -29px;}
#cboxBottomRight{width:21px; height:21px; background:url(images/controls.png) no-repeat -130px -29px;}
#cboxMiddleLeft{width:21px; background:url(images/controls.png) left top repeat-y;}
#cboxMiddleRight{width:21px; background:url(images/controls.png) right top repeat-y;}
#cboxTopCenter{height:21px; background:url(images/border.png) 0 0 repeat-x;}
#cboxBottomCenter{height:21px; background:url(images/border.png) 0 -29px repeat-x;}
#cboxContent{background:#fff; overflow:hidden;}
.cboxIframe{background:#fff;}
#cboxError{padding:50px; border:1px solid #ccc;}
#cboxLoadedContent{margin-bottom:28px;}
#cboxTitle{position:absolute; bottom:4px; left:0; text-align:center; width:100%; color:#949494;}
#cboxCurrent{position:absolute; bottom:4px; left:58px; color:#949494;}
#cboxLoadingOverlay{background:url(images/loading_background.png) no-repeat center center;}
#cboxLoadingGraphic{background:url(images/loading.gif) no-repeat center center;}
/* these elements are buttons, and may need to have additional styles reset to avoid unwanted base styles */
#cboxPrevious, #cboxNext, #cboxSlideshow, #cboxClose {border:0; padding:0; margin:0; overflow:visible; width:auto; background:none; }
/* avoid outlines on :active (mouseclick), but preserve outlines on :focus (tabbed navigating) */
#cboxPrevious:active, #cboxNext:active, #cboxSlideshow:active, #cboxClose:active {outline:0;}
#cboxSlideshow{position:absolute; bottom:4px; right:30px; color:#0092ef;}
#cboxPrevious{position:absolute; bottom:0; left:0; background:url(images/controls.png) no-repeat -75px 0; width:25px; height:25px; text-indent:-9999px;}
#cboxPrevious:hover{background-position:-75px -25px;}
#cboxNext{position:absolute; bottom:0; left:27px; background:url(images/controls.png) no-repeat -50px 0; width:25px; height:25px; text-indent:-9999px;}
#cboxNext:hover{background-position:-50px -25px;}
#cboxClose{position:absolute; bottom:0; right:0; background:url(images/controls.png) no-repeat -25px 0; width:25px; height:25px; text-indent:-9999px;}
#cboxClose:hover{background-position:-25px -25px;}
/*
The following fixes a problem where IE7 and IE8 replace a PNG's alpha transparency with a black fill
when an alpha filter (opacity change) is set on the element or ancestor element. This style is not applied to or needed in IE9.
See: http://jacklmoore.com/notes/ie-transparency-problems/
*/
.cboxIE #cboxTopLeft,
.cboxIE #cboxTopCenter,
.cboxIE #cboxTopRight,
.cboxIE #cboxBottomLeft,
.cboxIE #cboxBottomCenter,
.cboxIE #cboxBottomRight,
.cboxIE #cboxMiddleLeft,
.cboxIE #cboxMiddleRight {
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#00FFFFFF,endColorstr=#00FFFFFF);
} | Java |
<?php
/**
* @file
* Contains \Drupal\Tests\Core\Form\FormBuilderTest.
*/
namespace Drupal\Tests\Core\Form;
use Drupal\Component\Utility\NestedArray;
use Drupal\Core\Access\AccessResult;
use Drupal\Core\Access\AccessResultForbidden;
use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
use Drupal\Core\Form\EnforcedResponseException;
use Drupal\Core\Form\FormBuilderInterface;
use Drupal\Core\Form\FormInterface;
use Drupal\Core\Form\FormState;
use Drupal\Core\Form\FormStateInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Drupal\Core\Cache\Context\CacheContextsManager;
use Symfony\Component\DependencyInjection\ContainerBuilder;
/**
* @coversDefaultClass \Drupal\Core\Form\FormBuilder
* @group Form
*/
class FormBuilderTest extends FormTestBase {
/**
* The dependency injection container.
*
* @var \Symfony\Component\DependencyInjection\ContainerBuilder
*/
protected $container;
/**
* {@inheritdoc}
*/
protected function setUp() {
parent::setUp();
$this->container = new ContainerBuilder();
$cache_contexts_manager = $this->prophesize(CacheContextsManager::class)->reveal();
$this->container->set('cache_contexts_manager', $cache_contexts_manager);
\Drupal::setContainer($this->container);
}
/**
* Tests the getFormId() method with a string based form ID.
*
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage The form argument foo is not a valid form.
*/
public function testGetFormIdWithString() {
$form_arg = 'foo';
$clean_form_state = new FormState();
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame($form_arg, $form_id);
$this->assertSame($clean_form_state, $form_state);
}
/**
* Tests the getFormId() method with a class name form ID.
*/
public function testGetFormIdWithClassName() {
$form_arg = 'Drupal\Tests\Core\Form\TestForm';
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame('test_form', $form_id);
$this->assertSame($form_arg, get_class($form_state->getFormObject()));
}
/**
* Tests the getFormId() method with an injected class name form ID.
*/
public function testGetFormIdWithInjectedClassName() {
$container = $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface');
\Drupal::setContainer($container);
$form_arg = 'Drupal\Tests\Core\Form\TestFormInjected';
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame('test_form', $form_id);
$this->assertSame($form_arg, get_class($form_state->getFormObject()));
}
/**
* Tests the getFormId() method with a form object.
*/
public function testGetFormIdWithObject() {
$expected_form_id = 'my_module_form_id';
$form_arg = $this->getMockForm($expected_form_id);
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame($expected_form_id, $form_id);
$this->assertSame($form_arg, $form_state->getFormObject());
}
/**
* Tests the getFormId() method with a base form object.
*/
public function testGetFormIdWithBaseForm() {
$expected_form_id = 'my_module_form_id';
$base_form_id = 'my_module';
$form_arg = $this->getMock('Drupal\Core\Form\BaseFormIdInterface');
$form_arg->expects($this->once())
->method('getFormId')
->will($this->returnValue($expected_form_id));
$form_arg->expects($this->once())
->method('getBaseFormId')
->will($this->returnValue($base_form_id));
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame($expected_form_id, $form_id);
$this->assertSame($form_arg, $form_state->getFormObject());
$this->assertSame($base_form_id, $form_state->getBuildInfo()['base_form_id']);
}
/**
* Tests the handling of FormStateInterface::$response.
*
* @dataProvider formStateResponseProvider
*/
public function testHandleFormStateResponse($class, $form_state_key) {
$form_id = 'test_form_id';
$expected_form = $form_id();
$response = $this->getMockBuilder($class)
->disableOriginalConstructor()
->getMock();
$form_arg = $this->getMockForm($form_id, $expected_form);
$form_arg->expects($this->any())
->method('submitForm')
->will($this->returnCallback(function ($form, FormStateInterface $form_state) use ($response, $form_state_key) {
$form_state->setFormState([$form_state_key => $response]);
}));
$form_state = new FormState();
try {
$input['form_id'] = $form_id;
$form_state->setUserInput($input);
$this->simulateFormSubmission($form_id, $form_arg, $form_state, FALSE);
$this->fail('EnforcedResponseException was not thrown.');
}
catch (EnforcedResponseException $e) {
$this->assertSame($response, $e->getResponse());
}
$this->assertSame($response, $form_state->getResponse());
}
/**
* Provides test data for testHandleFormStateResponse().
*/
public function formStateResponseProvider() {
return array(
array('Symfony\Component\HttpFoundation\Response', 'response'),
array('Symfony\Component\HttpFoundation\RedirectResponse', 'redirect'),
);
}
/**
* Tests the handling of a redirect when FormStateInterface::$response exists.
*/
public function testHandleRedirectWithResponse() {
$form_id = 'test_form_id';
$expected_form = $form_id();
// Set up a response that will be used.
$response = $this->getMockBuilder('Symfony\Component\HttpFoundation\Response')
->disableOriginalConstructor()
->getMock();
// Set up a redirect that will not be called.
$redirect = $this->getMockBuilder('Symfony\Component\HttpFoundation\RedirectResponse')
->disableOriginalConstructor()
->getMock();
$form_arg = $this->getMockForm($form_id, $expected_form);
$form_arg->expects($this->any())
->method('submitForm')
->will($this->returnCallback(function ($form, FormStateInterface $form_state) use ($response, $redirect) {
// Set both the response and the redirect.
$form_state->setResponse($response);
$form_state->set('redirect', $redirect);
}));
$form_state = new FormState();
try {
$input['form_id'] = $form_id;
$form_state->setUserInput($input);
$this->simulateFormSubmission($form_id, $form_arg, $form_state, FALSE);
$this->fail('EnforcedResponseException was not thrown.');
}
catch (EnforcedResponseException $e) {
$this->assertSame($response, $e->getResponse());
}
$this->assertSame($response, $form_state->getResponse());
}
/**
* Tests the getForm() method with a string based form ID.
*
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage The form argument test_form_id is not a valid form.
*/
public function testGetFormWithString() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$form = $this->formBuilder->getForm($form_id);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertSame('test-form-id', $form['#id']);
}
/**
* Tests the getForm() method with a form object.
*/
public function testGetFormWithObject() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$form_arg = $this->getMockForm($form_id, $expected_form);
$form = $this->formBuilder->getForm($form_arg);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertArrayHasKey('#id', $form);
}
/**
* Tests the getForm() method with a class name based form ID.
*/
public function testGetFormWithClassString() {
$form_id = '\Drupal\Tests\Core\Form\TestForm';
$object = new TestForm();
$form = array();
$form_state = new FormState();
$expected_form = $object->buildForm($form, $form_state);
$form = $this->formBuilder->getForm($form_id);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertSame('test-form', $form['#id']);
}
/**
* Tests the buildForm() method with a string based form ID.
*
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage The form argument test_form_id is not a valid form.
*/
public function testBuildFormWithString() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$form = $this->formBuilder->getForm($form_id);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertArrayHasKey('#id', $form);
}
/**
* Tests the buildForm() method with a class name based form ID.
*/
public function testBuildFormWithClassString() {
$form_id = '\Drupal\Tests\Core\Form\TestForm';
$object = new TestForm();
$form = array();
$form_state = new FormState();
$expected_form = $object->buildForm($form, $form_state);
$form = $this->formBuilder->buildForm($form_id, $form_state);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertSame('test-form', $form['#id']);
}
/**
* Tests the buildForm() method with a form object.
*/
public function testBuildFormWithObject() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$form_arg = $this->getMockForm($form_id, $expected_form);
$form_state = new FormState();
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertSame($form_id, $form_state->getBuildInfo()['form_id']);
$this->assertArrayHasKey('#id', $form);
}
/**
* Tests the rebuildForm() method for a POST submission.
*/
public function testRebuildForm() {
$form_id = 'test_form_id';
$expected_form = $form_id();
// The form will be built four times.
$form_arg = $this->getMock('Drupal\Core\Form\FormInterface');
$form_arg->expects($this->exactly(2))
->method('getFormId')
->will($this->returnValue($form_id));
$form_arg->expects($this->exactly(4))
->method('buildForm')
->will($this->returnValue($expected_form));
// Do an initial build of the form and track the build ID.
$form_state = new FormState();
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$original_build_id = $form['#build_id'];
$this->request->setMethod('POST');
$form_state->setRequestMethod('POST');
// Rebuild the form, and assert that the build ID has not changed.
$form_state->setRebuild();
$input['form_id'] = $form_id;
$form_state->setUserInput($input);
$form_state->addRebuildInfo('copy', ['#build_id' => TRUE]);
$this->formBuilder->processForm($form_id, $form, $form_state);
$this->assertSame($original_build_id, $form['#build_id']);
$this->assertTrue($form_state->isCached());
// Rebuild the form again, and assert that there is a new build ID.
$form_state->setRebuildInfo([]);
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$this->assertNotSame($original_build_id, $form['#build_id']);
$this->assertTrue($form_state->isCached());
}
/**
* Tests the rebuildForm() method for a GET submission.
*/
public function testRebuildFormOnGetRequest() {
$form_id = 'test_form_id';
$expected_form = $form_id();
// The form will be built four times.
$form_arg = $this->getMock('Drupal\Core\Form\FormInterface');
$form_arg->expects($this->exactly(2))
->method('getFormId')
->will($this->returnValue($form_id));
$form_arg->expects($this->exactly(4))
->method('buildForm')
->will($this->returnValue($expected_form));
// Do an initial build of the form and track the build ID.
$form_state = new FormState();
$form_state->setMethod('GET');
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$original_build_id = $form['#build_id'];
// Rebuild the form, and assert that the build ID has not changed.
$form_state->setRebuild();
$input['form_id'] = $form_id;
$form_state->setUserInput($input);
$form_state->addRebuildInfo('copy', ['#build_id' => TRUE]);
$this->formBuilder->processForm($form_id, $form, $form_state);
$this->assertSame($original_build_id, $form['#build_id']);
$this->assertFalse($form_state->isCached());
// Rebuild the form again, and assert that there is a new build ID.
$form_state->setRebuildInfo([]);
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$this->assertNotSame($original_build_id, $form['#build_id']);
$this->assertFalse($form_state->isCached());
}
/**
* Tests the getCache() method.
*/
public function testGetCache() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$expected_form['#token'] = FALSE;
// FormBuilder::buildForm() will be called twice, but the form object will
// only be called once due to caching.
$form_arg = $this->getMock('Drupal\Core\Form\FormInterface');
$form_arg->expects($this->exactly(2))
->method('getFormId')
->will($this->returnValue($form_id));
$form_arg->expects($this->once())
->method('buildForm')
->will($this->returnValue($expected_form));
// Do an initial build of the form and track the build ID.
$form_state = (new FormState())
->addBuildInfo('files', [['module' => 'node', 'type' => 'pages.inc']])
->setRequestMethod('POST')
->setCached();
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$cached_form = $form;
$cached_form['#cache_token'] = 'csrf_token';
// The form cache, form_state cache, and CSRF token validation will only be
// called on the cached form.
$this->formCache->expects($this->once())
->method('getCache')
->willReturn($form);
// The final form build will not trigger any actual form building, but will
// use the form cache.
$form_state->setExecuted();
$input['form_id'] = $form_id;
$input['form_build_id'] = $form['#build_id'];
$form_state->setUserInput($input);
$this->formBuilder->buildForm($form_arg, $form_state);
$this->assertEmpty($form_state->getErrors());
}
/**
* Tests that HTML IDs are unique when rebuilding a form with errors.
*/
public function testUniqueHtmlId() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$expected_form['test']['#required'] = TRUE;
// Mock a form object that will be built two times.
$form_arg = $this->getMock('Drupal\Core\Form\FormInterface');
$form_arg->expects($this->exactly(2))
->method('getFormId')
->will($this->returnValue($form_id));
$form_arg->expects($this->exactly(2))
->method('buildForm')
->will($this->returnValue($expected_form));
$form_state = new FormState();
$form = $this->simulateFormSubmission($form_id, $form_arg, $form_state);
$this->assertSame('test-form-id', $form['#id']);
$form_state = new FormState();
$form = $this->simulateFormSubmission($form_id, $form_arg, $form_state);
$this->assertSame('test-form-id--2', $form['#id']);
}
/**
* Tests that a cached form is deleted after submit.
*/
public function testFormCacheDeletionCached() {
$form_id = 'test_form_id';
$form_build_id = $this->randomMachineName();
$expected_form = $form_id();
$expected_form['#build_id'] = $form_build_id;
$form_arg = $this->getMockForm($form_id, $expected_form);
$form_arg->expects($this->once())
->method('submitForm')
->willReturnCallback(function (array &$form, FormStateInterface $form_state) {
// Mimic EntityForm by cleaning the $form_state upon submit.
$form_state->cleanValues();
});
$this->formCache->expects($this->once())
->method('deleteCache')
->with($form_build_id);
$form_state = new FormState();
$form_state->setRequestMethod('POST');
$form_state->setCached();
$this->simulateFormSubmission($form_id, $form_arg, $form_state);
}
/**
* Tests that an uncached form does not trigger cache set or delete.
*/
public function testFormCacheDeletionUncached() {
$form_id = 'test_form_id';
$form_build_id = $this->randomMachineName();
$expected_form = $form_id();
$expected_form['#build_id'] = $form_build_id;
$form_arg = $this->getMockForm($form_id, $expected_form);
$this->formCache->expects($this->never())
->method('deleteCache');
$form_state = new FormState();
$this->simulateFormSubmission($form_id, $form_arg, $form_state);
}
/**
* @covers ::buildForm
*
* @expectedException \Drupal\Core\Form\Exception\BrokenPostRequestException
*/
public function testExceededFileSize() {
$request = new Request([FormBuilderInterface::AJAX_FORM_REQUEST => TRUE]);
$request_stack = new RequestStack();
$request_stack->push($request);
$this->formBuilder = $this->getMockBuilder('\Drupal\Core\Form\FormBuilder')
->setConstructorArgs([$this->formValidator, $this->formSubmitter, $this->formCache, $this->moduleHandler, $this->eventDispatcher, $request_stack, $this->classResolver, $this->elementInfo, $this->themeManager, $this->csrfToken])
->setMethods(['getFileUploadMaxSize'])
->getMock();
$this->formBuilder->expects($this->once())
->method('getFileUploadMaxSize')
->willReturn(33554432);
$form_arg = $this->getMockForm('test_form_id');
$form_state = new FormState();
$this->formBuilder->buildForm($form_arg, $form_state);
}
/**
* @covers ::buildForm
*
* @dataProvider providerTestChildAccessInheritance
*/
public function testChildAccessInheritance($element, $access_checks) {
$form_arg = new TestFormWithPredefinedForm();
$form_arg->setForm($element);
$form_state = new FormState();
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$actual_access_structure = [];
$expected_access_structure = [];
// Ensure that the expected access checks are set.
foreach ($access_checks as $access_check) {
$parents = $access_check[0];
$parents[] = '#access';
$actual_access = NestedArray::getValue($form, $parents);
$actual_access_structure[] = [$parents, $actual_access];
$expected_access_structure[] = [$parents, $access_check[1]];
}
$this->assertEquals($expected_access_structure, $actual_access_structure);
}
/**
* Data provider for testChildAccessInheritance.
*
* @return array
*/
public function providerTestChildAccessInheritance() {
$data = [];
$element = [
'child0' => [
'#type' => 'checkbox',
],
'child1' => [
'#type' => 'checkbox',
],
'child2' => [
'#type' => 'fieldset',
'child2.0' => [
'#type' => 'checkbox',
],
'child2.1' => [
'#type' => 'checkbox',
],
'child2.2' => [
'#type' => 'checkbox',
],
],
];
// Sets access FALSE on the root level, this should be inherited completely.
$clone = $element;
$clone['#access'] = FALSE;
$expected_access = [];
$expected_access[] = [[], FALSE];
$expected_access[] = [['child0'], FALSE];
$expected_access[] = [['child1'], FALSE];
$expected_access[] = [['child2'], FALSE];
$expected_access[] = [['child2', 'child2.0'], FALSE];
$expected_access[] = [['child2', 'child2.1'], FALSE];
$expected_access[] = [['child2', 'child2.2'], FALSE];
$data['access-false-root'] = [$clone, $expected_access];
$clone = $element;
$access_result = AccessResult::forbidden();
$clone['#access'] = $access_result;
$expected_access = [];
$expected_access[] = [[], $access_result];
$expected_access[] = [['child0'], $access_result];
$expected_access[] = [['child1'], $access_result];
$expected_access[] = [['child2'], $access_result];
$expected_access[] = [['child2', 'child2.0'], $access_result];
$expected_access[] = [['child2', 'child2.1'], $access_result];
$expected_access[] = [['child2', 'child2.2'], $access_result];
$data['access-forbidden-root'] = [$clone, $expected_access];
// Allow access on the most outer level but set FALSE otherwise.
$clone = $element;
$clone['#access'] = TRUE;
$clone['child0']['#access'] = FALSE;
$expected_access = [];
$expected_access[] = [[], TRUE];
$expected_access[] = [['child0'], FALSE];
$expected_access[] = [['child1'], NULL];
$expected_access[] = [['child2'], NULL];
$expected_access[] = [['child2', 'child2.0'], NULL];
$expected_access[] = [['child2', 'child2.1'], NULL];
$expected_access[] = [['child2', 'child2.2'], NULL];
$data['access-true-root'] = [$clone, $expected_access];
// Allow access on the most outer level but forbid otherwise.
$clone = $element;
$access_result_allowed = AccessResult::allowed();
$clone['#access'] = $access_result_allowed;
$access_result_forbidden = AccessResult::forbidden();
$clone['child0']['#access'] = $access_result_forbidden;
$expected_access = [];
$expected_access[] = [[], $access_result_allowed];
$expected_access[] = [['child0'], $access_result_forbidden];
$expected_access[] = [['child1'], NULL];
$expected_access[] = [['child2'], NULL];
$expected_access[] = [['child2', 'child2.0'], NULL];
$expected_access[] = [['child2', 'child2.1'], NULL];
$expected_access[] = [['child2', 'child2.2'], NULL];
$data['access-allowed-root'] = [$clone, $expected_access];
// Allow access on the most outer level, deny access on a parent, and allow
// on a child. The denying should be inherited.
$clone = $element;
$clone['#access'] = TRUE;
$clone['child2']['#access'] = FALSE;
$clone['child2.0']['#access'] = TRUE;
$clone['child2.1']['#access'] = TRUE;
$clone['child2.2']['#access'] = TRUE;
$expected_access = [];
$expected_access[] = [[], TRUE];
$expected_access[] = [['child0'], NULL];
$expected_access[] = [['child1'], NULL];
$expected_access[] = [['child2'], FALSE];
$expected_access[] = [['child2', 'child2.0'], FALSE];
$expected_access[] = [['child2', 'child2.1'], FALSE];
$expected_access[] = [['child2', 'child2.2'], FALSE];
$data['access-mixed-parents'] = [$clone, $expected_access];
$clone = $element;
$clone['#access'] = $access_result_allowed;
$clone['child2']['#access'] = $access_result_forbidden;
$clone['child2.0']['#access'] = $access_result_allowed;
$clone['child2.1']['#access'] = $access_result_allowed;
$clone['child2.2']['#access'] = $access_result_allowed;
$expected_access = [];
$expected_access[] = [[], $access_result_allowed];
$expected_access[] = [['child0'], NULL];
$expected_access[] = [['child1'], NULL];
$expected_access[] = [['child2'], $access_result_forbidden];
$expected_access[] = [['child2', 'child2.0'], $access_result_forbidden];
$expected_access[] = [['child2', 'child2.1'], $access_result_forbidden];
$expected_access[] = [['child2', 'child2.2'], $access_result_forbidden];
$data['access-mixed-parents-object'] = [$clone, $expected_access];
return $data;
}
}
class TestForm implements FormInterface {
public function getFormId() {
return 'test_form';
}
public function buildForm(array $form, FormStateInterface $form_state) {
return test_form_id();
}
public function validateForm(array &$form, FormStateInterface $form_state) { }
public function submitForm(array &$form, FormStateInterface $form_state) { }
}
class TestFormInjected extends TestForm implements ContainerInjectionInterface {
public static function create(ContainerInterface $container) {
return new static();
}
}
class TestFormWithPredefinedForm extends TestForm {
/**
* @var array
*/
protected $form;
public function setForm($form) {
$this->form = $form;
}
public function buildForm(array $form, FormStateInterface $form_state) {
return $this->form;
}
}
| Java |
<?php
/**
* DmUserGroupTable
*
* This class has been auto-generated by the Doctrine ORM Framework
*/
class DmUserGroupTable extends PluginDmUserGroupTable
{
/**
* Returns an instance of this class.
*
* @return DmUserGroupTable The table object
*/
public static function getInstance()
{
return Doctrine_Core::getTable('DmUserGroup');
}
} | Java |
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package database.parse.util;
import almonds.Parse;
import almonds.ParseObject;
import database.parse.tables.ParsePhenomena;
import database.parse.tables.ParseSensor;
import java.net.URI;
/**
*
* @author jried31
*/
public class DBGlobals {
static public String TABLE_PHENOMENA="tester";
static public String TABLE_SENSOR="Sensor";
public static String URL_GOOGLE_SEARCH="http://suggestqueries.google.com/complete/search?client=firefox&hl=en&q=WORD";
//http://clients1.google.com/complete/search?noLabels=t&client=web&q=WORD";
public static void InitializeParse(){
//App Ids for Connecting to the Parse DB
Parse.initialize("jEciFYpTp2b1XxHuIkmAs3yaP70INpkBDg9WdTl9", //Application ID
"aPEXcVv80kHwfVJK1WEKWckePkWxYNEXBovIR6d5"); //Rest API Key
}
}
| Java |
/*
* f_mass_storage.c -- Mass Storage USB Composite Function
*
* Copyright (C) 2003-2008 Alan Stern
* Copyright (C) 2009 Samsung Electronics
* Author: Michal Nazarewicz <mina86@mina86.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The names of the above-listed copyright holders may not be used
* to endorse or promote products derived from this software without
* specific prior written permission.
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* The Mass Storage Function acts as a USB Mass Storage device,
* appearing to the host as a disk drive or as a CD-ROM drive. In
* addition to providing an example of a genuinely useful composite
* function for a USB device, it also illustrates a technique of
* double-buffering for increased throughput.
*
* For more information about MSF and in particular its module
* parameters and sysfs interface read the
* <Documentation/usb/mass-storage.txt> file.
*/
/*
* MSF is configured by specifying a fsg_config structure. It has the
* following fields:
*
* nluns Number of LUNs function have (anywhere from 1
* to FSG_MAX_LUNS which is 8).
* luns An array of LUN configuration values. This
* should be filled for each LUN that
* function will include (ie. for "nluns"
* LUNs). Each element of the array has
* the following fields:
* ->filename The path to the backing file for the LUN.
* Required if LUN is not marked as
* removable.
* ->ro Flag specifying access to the LUN shall be
* read-only. This is implied if CD-ROM
* emulation is enabled as well as when
* it was impossible to open "filename"
* in R/W mode.
* ->removable Flag specifying that LUN shall be indicated as
* being removable.
* ->cdrom Flag specifying that LUN shall be reported as
* being a CD-ROM.
* ->nofua Flag specifying that FUA flag in SCSI WRITE(10,12)
* commands for this LUN shall be ignored.
*
* vendor_name
* product_name
* release Information used as a reply to INQUIRY
* request. To use default set to NULL,
* NULL, 0xffff respectively. The first
* field should be 8 and the second 16
* characters or less.
*
* can_stall Set to permit function to halt bulk endpoints.
* Disabled on some USB devices known not
* to work correctly. You should set it
* to true.
*
* If "removable" is not set for a LUN then a backing file must be
* specified. If it is set, then NULL filename means the LUN's medium
* is not loaded (an empty string as "filename" in the fsg_config
* structure causes error). The CD-ROM emulation includes a single
* data track and no audio tracks; hence there need be only one
* backing file per LUN.
*
* This function is heavily based on "File-backed Storage Gadget" by
* Alan Stern which in turn is heavily based on "Gadget Zero" by David
* Brownell. The driver's SCSI command interface was based on the
* "Information technology - Small Computer System Interface - 2"
* document from X3T9.2 Project 375D, Revision 10L, 7-SEP-93,
* available at <http://www.t10.org/ftp/t10/drafts/s2/s2-r10l.pdf>.
* The single exception is opcode 0x23 (READ FORMAT CAPACITIES), which
* was based on the "Universal Serial Bus Mass Storage Class UFI
* Command Specification" document, Revision 1.0, December 14, 1998,
* available at
* <http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf>.
*/
/*
* Driver Design
*
* The MSF is fairly straightforward. There is a main kernel
* thread that handles most of the work. Interrupt routines field
* callbacks from the controller driver: bulk- and interrupt-request
* completion notifications, endpoint-0 events, and disconnect events.
* Completion events are passed to the main thread by wakeup calls. Many
* ep0 requests are handled at interrupt time, but SetInterface,
* SetConfiguration, and device reset requests are forwarded to the
* thread in the form of "exceptions" using SIGUSR1 signals (since they
* should interrupt any ongoing file I/O operations).
*
* The thread's main routine implements the standard command/data/status
* parts of a SCSI interaction. It and its subroutines are full of tests
* for pending signals/exceptions -- all this polling is necessary since
* the kernel has no setjmp/longjmp equivalents. (Maybe this is an
* indication that the driver really wants to be running in userspace.)
* An important point is that so long as the thread is alive it keeps an
* open reference to the backing file. This will prevent unmounting
* the backing file's underlying filesystem and could cause problems
* during system shutdown, for example. To prevent such problems, the
* thread catches INT, TERM, and KILL signals and converts them into
* an EXIT exception.
*
* In normal operation the main thread is started during the gadget's
* fsg_bind() callback and stopped during fsg_unbind(). But it can
* also exit when it receives a signal, and there's no point leaving
* the gadget running when the thread is dead. As of this moment, MSF
* provides no way to deregister the gadget when thread dies -- maybe
* a callback functions is needed.
*
* To provide maximum throughput, the driver uses a circular pipeline of
* buffer heads (struct fsg_buffhd). In principle the pipeline can be
* arbitrarily long; in practice the benefits don't justify having more
* than 2 stages (i.e., double buffering). But it helps to think of the
* pipeline as being a long one. Each buffer head contains a bulk-in and
* a bulk-out request pointer (since the buffer can be used for both
* output and input -- directions always are given from the host's
* point of view) as well as a pointer to the buffer and various state
* variables.
*
* Use of the pipeline follows a simple protocol. There is a variable
* (fsg->next_buffhd_to_fill) that points to the next buffer head to use.
* At any time that buffer head may still be in use from an earlier
* request, so each buffer head has a state variable indicating whether
* it is EMPTY, FULL, or BUSY. Typical use involves waiting for the
* buffer head to be EMPTY, filling the buffer either by file I/O or by
* USB I/O (during which the buffer head is BUSY), and marking the buffer
* head FULL when the I/O is complete. Then the buffer will be emptied
* (again possibly by USB I/O, during which it is marked BUSY) and
* finally marked EMPTY again (possibly by a completion routine).
*
* A module parameter tells the driver to avoid stalling the bulk
* endpoints wherever the transport specification allows. This is
* necessary for some UDCs like the SuperH, which cannot reliably clear a
* halt on a bulk endpoint. However, under certain circumstances the
* Bulk-only specification requires a stall. In such cases the driver
* will halt the endpoint and set a flag indicating that it should clear
* the halt in software during the next device reset. Hopefully this
* will permit everything to work correctly. Furthermore, although the
* specification allows the bulk-out endpoint to halt when the host sends
* too much data, implementing this would cause an unavoidable race.
* The driver will always use the "no-stall" approach for OUT transfers.
*
* One subtle point concerns sending status-stage responses for ep0
* requests. Some of these requests, such as device reset, can involve
* interrupting an ongoing file I/O operation, which might take an
* arbitrarily long time. During that delay the host might give up on
* the original ep0 request and issue a new one. When that happens the
* driver should not notify the host about completion of the original
* request, as the host will no longer be waiting for it. So the driver
* assigns to each ep0 request a unique tag, and it keeps track of the
* tag value of the request associated with a long-running exception
* (device-reset, interface-change, or configuration-change). When the
* exception handler is finished, the status-stage response is submitted
* only if the current ep0 request tag is equal to the exception request
* tag. Thus only the most recently received ep0 request will get a
* status-stage response.
*
* Warning: This driver source file is too long. It ought to be split up
* into a header file plus about 3 separate .c files, to handle the details
* of the Gadget, USB Mass Storage, and SCSI protocols.
*/
/* #define VERBOSE_DEBUG */
/* #define DUMP_MSGS */
#include <linux/blkdev.h>
#include <linux/completion.h>
#include <linux/dcache.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/fcntl.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/kref.h>
#include <linux/kthread.h>
#include <linux/limits.h>
#include <linux/rwsem.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/string.h>
#include <linux/freezer.h>
#include <linux/module.h>
#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
#include <linux/usb/composite.h>
#include "gadget_chips.h"
#include "configfs.h"
/*------------------------------------------------------------------------*/
#define FSG_DRIVER_DESC "Mass Storage Function"
#define FSG_DRIVER_VERSION "2009/09/11"
static const char fsg_string_interface[] = "Mass Storage";
#include "storage_common.h"
#include "f_mass_storage.h"
/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
static struct usb_string fsg_strings[] = {
{FSG_STRING_INTERFACE, fsg_string_interface},
{}
};
static struct usb_gadget_strings fsg_stringtab = {
.language = 0x0409, /* en-us */
.strings = fsg_strings,
};
static struct usb_gadget_strings *fsg_strings_array[] = {
&fsg_stringtab,
NULL,
};
/*-------------------------------------------------------------------------*/
/*
* If USB mass storage vfs operation is stuck for more than 10 sec
* host will initiate the reset. Configure the timer with 9 sec to print
* the error message before host is intiating the resume on it.
*/
#define MSC_VFS_TIMER_PERIOD_MS 9000
static int msc_vfs_timer_period_ms = MSC_VFS_TIMER_PERIOD_MS;
module_param(msc_vfs_timer_period_ms, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(msc_vfs_timer_period_ms, "Set period for MSC VFS timer");
static int write_error_after_csw_sent;
static int must_report_residue;
static int csw_sent;
struct fsg_dev;
struct fsg_common;
/* Data shared by all the FSG instances. */
struct fsg_common {
struct usb_gadget *gadget;
struct usb_composite_dev *cdev;
struct fsg_dev *fsg, *new_fsg;
wait_queue_head_t fsg_wait;
/* filesem protects: backing files in use */
struct rw_semaphore filesem;
/* lock protects: state, all the req_busy's */
spinlock_t lock;
struct usb_ep *ep0; /* Copy of gadget->ep0 */
struct usb_request *ep0req; /* Copy of cdev->req */
unsigned int ep0_req_tag;
struct fsg_buffhd *next_buffhd_to_fill;
struct fsg_buffhd *next_buffhd_to_drain;
struct fsg_buffhd *buffhds;
unsigned int fsg_num_buffers;
int cmnd_size;
u8 cmnd[MAX_COMMAND_SIZE];
unsigned int nluns;
unsigned int lun;
struct fsg_lun **luns;
struct fsg_lun *curlun;
unsigned int bulk_out_maxpacket;
enum fsg_state state; /* For exception handling */
unsigned int exception_req_tag;
enum data_direction data_dir;
u32 data_size;
u32 data_size_from_cmnd;
u32 tag;
u32 residue;
u32 usb_amount_left;
unsigned int can_stall:1;
unsigned int free_storage_on_release:1;
unsigned int phase_error:1;
unsigned int short_packet_received:1;
unsigned int bad_lun_okay:1;
unsigned int running:1;
unsigned int sysfs:1;
int thread_wakeup_needed;
struct completion thread_notifier;
struct task_struct *thread_task;
/* Callback functions. */
const struct fsg_operations *ops;
/* Gadget's private data. */
void *private_data;
char inquiry_string[INQUIRY_MAX_LEN];
/* LUN name for sysfs purpose */
char name[FSG_MAX_LUNS][LUN_NAME_LEN];
struct kref ref;
struct timer_list vfs_timer;
};
struct fsg_dev {
struct usb_function function;
struct usb_gadget *gadget; /* Copy of cdev->gadget */
struct fsg_common *common;
u16 interface_number;
unsigned int bulk_in_enabled:1;
unsigned int bulk_out_enabled:1;
unsigned long atomic_bitflags;
#define IGNORE_BULK_OUT 0
struct usb_ep *bulk_in;
struct usb_ep *bulk_out;
};
static void msc_usb_vfs_timer_func(unsigned long data)
{
struct fsg_common *common = (struct fsg_common *) data;
switch (common->data_dir) {
case DATA_DIR_FROM_HOST:
dev_err(&common->curlun->dev,
"usb mass storage stuck in vfs_write\n");
break;
case DATA_DIR_TO_HOST:
dev_err(&common->curlun->dev,
"usb mass storage stuck in vfs_read\n");
break;
default:
dev_err(&common->curlun->dev,
"usb mass storage stuck in vfs_sync\n");
break;
}
}
static inline int __fsg_is_set(struct fsg_common *common,
const char *func, unsigned line)
{
if (common->fsg)
return 1;
ERROR(common, "common->fsg is NULL in %s at %u\n", func, line);
WARN_ON(1);
return 0;
}
#define fsg_is_set(common) likely(__fsg_is_set(common, __func__, __LINE__))
static inline struct fsg_dev *fsg_from_func(struct usb_function *f)
{
return container_of(f, struct fsg_dev, function);
}
typedef void (*fsg_routine_t)(struct fsg_dev *);
static int send_status(struct fsg_common *common);
static int exception_in_progress(struct fsg_common *common)
{
return common->state > FSG_STATE_IDLE;
}
/* Make bulk-out requests be divisible by the maxpacket size */
static void set_bulk_out_req_length(struct fsg_common *common,
struct fsg_buffhd *bh, unsigned int length)
{
unsigned int rem;
bh->bulk_out_intended_length = length;
rem = length % common->bulk_out_maxpacket;
if (rem > 0)
length += common->bulk_out_maxpacket - rem;
bh->outreq->length = length;
}
/*-------------------------------------------------------------------------*/
static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
{
const char *name;
if (ep == fsg->bulk_in)
name = "bulk-in";
else if (ep == fsg->bulk_out)
name = "bulk-out";
else
name = ep->name;
DBG(fsg, "%s set halt\n", name);
return usb_ep_set_halt(ep);
}
/*-------------------------------------------------------------------------*/
/* These routines may be called in process context or in_irq */
/* Caller must hold fsg->lock */
static void wakeup_thread(struct fsg_common *common)
{
smp_wmb(); /* ensure the write of bh->state is complete */
/* Tell the main thread that something has happened */
common->thread_wakeup_needed = 1;
if (common->thread_task)
wake_up_process(common->thread_task);
}
static void raise_exception(struct fsg_common *common, enum fsg_state new_state)
{
unsigned long flags;
/*
* Do nothing if a higher-priority exception is already in progress.
* If a lower-or-equal priority exception is in progress, preempt it
* and notify the main thread by sending it a signal.
*/
spin_lock_irqsave(&common->lock, flags);
if (common->state <= new_state) {
common->exception_req_tag = common->ep0_req_tag;
common->state = new_state;
if (common->thread_task)
send_sig_info(SIGUSR1, SEND_SIG_FORCED,
common->thread_task);
}
spin_unlock_irqrestore(&common->lock, flags);
}
/*-------------------------------------------------------------------------*/
static int ep0_queue(struct fsg_common *common)
{
int rc;
rc = usb_ep_queue(common->ep0, common->ep0req, GFP_ATOMIC);
common->ep0->driver_data = common;
if (rc != 0 && rc != -ESHUTDOWN) {
/* We can't do much more than wait for a reset */
WARNING(common, "error in submission: %s --> %d\n",
common->ep0->name, rc);
}
return rc;
}
/*-------------------------------------------------------------------------*/
/* Completion handlers. These always run in_irq. */
static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
{
struct fsg_common *common = ep->driver_data;
struct fsg_buffhd *bh = req->context;
if (req->status || req->actual != req->length)
pr_debug("%s --> %d, %u/%u\n", __func__,
req->status, req->actual, req->length);
if (req->status == -ECONNRESET) /* Request was cancelled */
usb_ep_fifo_flush(ep);
/* Hold the lock while we update the request and buffer states */
smp_wmb();
/*
* Disconnect and completion might race each other and driver data
* is set to NULL during ep disable. So, add a check if that is case.
*/
if (!common) {
bh->inreq_busy = 0;
bh->state = BUF_STATE_EMPTY;
return;
}
spin_lock(&common->lock);
bh->inreq_busy = 0;
bh->state = BUF_STATE_EMPTY;
wakeup_thread(common);
spin_unlock(&common->lock);
}
static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
{
struct fsg_common *common = ep->driver_data;
struct fsg_buffhd *bh = req->context;
dump_msg(common, "bulk-out", req->buf, req->actual);
if (req->status || req->actual != bh->bulk_out_intended_length)
DBG(common, "%s --> %d, %u/%u\n", __func__,
req->status, req->actual, bh->bulk_out_intended_length);
if (req->status == -ECONNRESET) /* Request was cancelled */
usb_ep_fifo_flush(ep);
/* Hold the lock while we update the request and buffer states */
smp_wmb();
spin_lock(&common->lock);
bh->outreq_busy = 0;
bh->state = BUF_STATE_FULL;
wakeup_thread(common);
spin_unlock(&common->lock);
}
static int fsg_setup(struct usb_function *f,
const struct usb_ctrlrequest *ctrl)
{
struct fsg_dev *fsg = fsg_from_func(f);
struct usb_request *req = fsg->common->ep0req;
u16 w_index = le16_to_cpu(ctrl->wIndex);
u16 w_value = le16_to_cpu(ctrl->wValue);
u16 w_length = le16_to_cpu(ctrl->wLength);
if (!fsg_is_set(fsg->common))
return -EOPNOTSUPP;
++fsg->common->ep0_req_tag; /* Record arrival of a new request */
req->context = NULL;
req->length = 0;
dump_msg(fsg, "ep0-setup", (u8 *) ctrl, sizeof(*ctrl));
switch (ctrl->bRequest) {
case US_BULK_RESET_REQUEST:
if (ctrl->bRequestType !=
(USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
break;
if (w_index != fsg->interface_number || w_value != 0 ||
w_length != 0)
return -EDOM;
/*
* Raise an exception to stop the current operation
* and reinitialize our state.
*/
DBG(fsg, "bulk reset request\n");
raise_exception(fsg->common, FSG_STATE_RESET);
return USB_GADGET_DELAYED_STATUS;
case US_BULK_GET_MAX_LUN:
if (ctrl->bRequestType !=
(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
break;
if (w_index != fsg->interface_number || w_value != 0 ||
w_length != 1)
return -EDOM;
VDBG(fsg, "get max LUN\n");
*(u8 *)req->buf = fsg->common->nluns - 1;
/* Respond with data/status */
req->length = min((u16)1, w_length);
return ep0_queue(fsg->common);
}
VDBG(fsg,
"unknown class-specific control req %02x.%02x v%04x i%04x l%u\n",
ctrl->bRequestType, ctrl->bRequest,
le16_to_cpu(ctrl->wValue), w_index, w_length);
return -EOPNOTSUPP;
}
/*-------------------------------------------------------------------------*/
/* All the following routines run in process context */
/* Use this for bulk or interrupt transfers, not ep0 */
static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
struct usb_request *req, int *pbusy,
enum fsg_buffer_state *state)
{
int rc;
if (ep == fsg->bulk_in)
dump_msg(fsg, "bulk-in", req->buf, req->length);
spin_lock_irq(&fsg->common->lock);
*pbusy = 1;
*state = BUF_STATE_BUSY;
spin_unlock_irq(&fsg->common->lock);
rc = usb_ep_queue(ep, req, GFP_KERNEL);
if (rc == 0)
return; /* All good, we're done */
*pbusy = 0;
*state = BUF_STATE_EMPTY;
/* We can't do much more than wait for a reset */
/*
* Note: currently the net2280 driver fails zero-length
* submissions if DMA is enabled.
*/
if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP && req->length == 0))
WARNING(fsg, "error in submission: %s --> %d\n", ep->name, rc);
}
static bool start_in_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
{
if (!fsg_is_set(common))
return false;
start_transfer(common->fsg, common->fsg->bulk_in,
bh->inreq, &bh->inreq_busy, &bh->state);
return true;
}
static bool start_out_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
{
if (!fsg_is_set(common))
return false;
start_transfer(common->fsg, common->fsg->bulk_out,
bh->outreq, &bh->outreq_busy, &bh->state);
return true;
}
static int sleep_thread(struct fsg_common *common, bool can_freeze)
{
int rc = 0;
/* Wait until a signal arrives or we are woken up */
for (;;) {
if (can_freeze)
try_to_freeze();
set_current_state(TASK_INTERRUPTIBLE);
if (signal_pending(current)) {
rc = -EINTR;
break;
}
spin_lock_irq(&common->lock);
if (common->thread_wakeup_needed) {
spin_unlock_irq(&common->lock);
break;
}
spin_unlock_irq(&common->lock);
schedule();
}
__set_current_state(TASK_RUNNING);
spin_lock_irq(&common->lock);
common->thread_wakeup_needed = 0;
spin_unlock_irq(&common->lock);
smp_rmb(); /* ensure the latest bh->state is visible */
return rc;
}
/*-------------------------------------------------------------------------*/
static int do_read(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
u32 lba;
struct fsg_buffhd *bh;
int rc;
u32 amount_left;
loff_t file_offset, file_offset_tmp;
unsigned int amount;
ssize_t nread;
ktime_t start, diff;
/*
* Get the starting Logical Block Address and check that it's
* not too big.
*/
if (common->cmnd[0] == READ_6)
lba = get_unaligned_be24(&common->cmnd[1]);
else {
lba = get_unaligned_be32(&common->cmnd[2]);
/*
* We allow DPO (Disable Page Out = don't save data in the
* cache) and FUA (Force Unit Access = don't read from the
* cache), but we don't implement them.
*/
if ((common->cmnd[1] & ~0x18) != 0) {
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
}
if (lba >= curlun->num_sectors) {
curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
return -EINVAL;
}
file_offset = ((loff_t) lba) << curlun->blkbits;
/* Carry out the file reads */
amount_left = common->data_size_from_cmnd;
if (unlikely(amount_left == 0))
return -EIO; /* No default reply */
for (;;) {
/*
* Figure out how much we need to read:
* Try to read the remaining amount.
* But don't read more than the buffer size.
* And don't try to read past the end of the file.
*/
amount = min(amount_left, FSG_BUFLEN);
amount = min((loff_t)amount,
curlun->file_length - file_offset);
/* Wait for the next buffer to become available */
spin_lock_irq(&common->lock);
bh = common->next_buffhd_to_fill;
while (bh->state != BUF_STATE_EMPTY) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, false);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
/*
* If we were asked to read past the end of file,
* end with an empty buffer.
*/
if (amount == 0) {
curlun->sense_data =
SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
spin_lock_irq(&common->lock);
bh->inreq->length = 0;
bh->state = BUF_STATE_FULL;
spin_unlock_irq(&common->lock);
break;
}
/* Perform the read */
file_offset_tmp = file_offset;
start = ktime_get();
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(msc_vfs_timer_period_ms));
nread = vfs_read(curlun->filp,
(char __user *)bh->buf,
amount, &file_offset_tmp);
del_timer_sync(&common->vfs_timer);
VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
(unsigned long long)file_offset, (int)nread);
diff = ktime_sub(ktime_get(), start);
curlun->perf.rbytes += nread;
curlun->perf.rtime = ktime_add(curlun->perf.rtime, diff);
if (signal_pending(current))
return -EINTR;
if (nread < 0) {
LDBG(curlun, "error in file read: %d\n", (int)nread);
nread = 0;
} else if (nread < amount) {
LDBG(curlun, "partial file read: %d/%u\n",
(int)nread, amount);
nread = round_down(nread, curlun->blksize);
}
file_offset += nread;
amount_left -= nread;
common->residue -= nread;
/*
* Except at the end of the transfer, nread will be
* equal to the buffer size, which is divisible by the
* bulk-in maxpacket size.
*/
spin_lock_irq(&common->lock);
bh->inreq->length = nread;
bh->state = BUF_STATE_FULL;
spin_unlock_irq(&common->lock);
/* If an error occurred, report it and its position */
if (nread < amount) {
curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
break;
}
if (amount_left == 0)
break; /* No more left to read */
/* Send this buffer and go read some more */
bh->inreq->zero = 0;
if (!start_in_transfer(common, bh))
/* Don't know what to do if common->fsg is NULL */
return -EIO;
common->next_buffhd_to_fill = bh->next;
}
return -EIO; /* No default reply */
}
/*-------------------------------------------------------------------------*/
static int do_write(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
u32 lba;
struct fsg_buffhd *bh;
int get_some_more;
u32 amount_left_to_req, amount_left_to_write;
loff_t usb_offset, file_offset, file_offset_tmp;
unsigned int amount;
ssize_t nwritten;
ktime_t start, diff;
int rc, i;
if (curlun->ro) {
curlun->sense_data = SS_WRITE_PROTECTED;
return -EINVAL;
}
spin_lock(&curlun->filp->f_lock);
curlun->filp->f_flags &= ~O_SYNC; /* Default is not to wait */
spin_unlock(&curlun->filp->f_lock);
/*
* Get the starting Logical Block Address and check that it's
* not too big
*/
if (common->cmnd[0] == WRITE_6)
lba = get_unaligned_be24(&common->cmnd[1]);
else {
lba = get_unaligned_be32(&common->cmnd[2]);
/*
* We allow DPO (Disable Page Out = don't save data in the
* cache) and FUA (Force Unit Access = write directly to the
* medium). We don't implement DPO; we implement FUA by
* performing synchronous output.
*/
if (common->cmnd[1] & ~0x18) {
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
if (!curlun->nofua && (common->cmnd[1] & 0x08)) { /* FUA */
spin_lock(&curlun->filp->f_lock);
curlun->filp->f_flags |= O_SYNC;
spin_unlock(&curlun->filp->f_lock);
}
}
if (lba >= curlun->num_sectors) {
curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
return -EINVAL;
}
/* Carry out the file writes */
get_some_more = 1;
file_offset = usb_offset = ((loff_t) lba) << curlun->blkbits;
amount_left_to_req = common->data_size_from_cmnd;
amount_left_to_write = common->data_size_from_cmnd;
while (amount_left_to_write > 0) {
/* Queue a request for more data from the host */
bh = common->next_buffhd_to_fill;
if (bh->state == BUF_STATE_EMPTY && get_some_more) {
/*
* Figure out how much we want to get:
* Try to get the remaining amount,
* but not more than the buffer size.
*/
amount = min(amount_left_to_req, FSG_BUFLEN);
/* Beyond the end of the backing file? */
if (usb_offset >= curlun->file_length) {
get_some_more = 0;
curlun->sense_data =
SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
curlun->sense_data_info =
usb_offset >> curlun->blkbits;
curlun->info_valid = 1;
continue;
}
/* Get the next buffer */
usb_offset += amount;
common->usb_amount_left -= amount;
amount_left_to_req -= amount;
if (amount_left_to_req == 0)
get_some_more = 0;
/*
* Except at the end of the transfer, amount will be
* equal to the buffer size, which is divisible by
* the bulk-out maxpacket size.
*/
set_bulk_out_req_length(common, bh, amount);
if (!start_out_transfer(common, bh))
/* Dunno what to do if common->fsg is NULL */
return -EIO;
common->next_buffhd_to_fill = bh->next;
continue;
}
/* Write the received data to the backing file */
bh = common->next_buffhd_to_drain;
if (bh->state == BUF_STATE_EMPTY && !get_some_more)
break; /* We stopped early */
/*
* If the csw packet is already submmitted to the hardware,
* by marking the state of buffer as full, then by checking
* the residue, we make sure that this csw packet is not
* written on to the storage media.
*/
if (bh->state == BUF_STATE_FULL && common->residue) {
smp_rmb();
common->next_buffhd_to_drain = bh->next;
bh->state = BUF_STATE_EMPTY;
/* Did something go wrong with the transfer? */
if (bh->outreq->status != 0) {
curlun->sense_data = SS_COMMUNICATION_FAILURE;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
break;
}
amount = bh->outreq->actual;
if (curlun->file_length - file_offset < amount) {
LERROR(curlun,
"write %u @ %llu beyond end %llu\n",
amount, (unsigned long long)file_offset,
(unsigned long long)curlun->file_length);
amount = curlun->file_length - file_offset;
}
/* Don't accept excess data. The spec doesn't say
* what to do in this case. We'll ignore the error.
*/
amount = min(amount, bh->bulk_out_intended_length);
/* Don't write a partial block */
amount = round_down(amount, curlun->blksize);
if (amount == 0)
goto empty_write;
/* Perform the write */
file_offset_tmp = file_offset;
start = ktime_get();
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(msc_vfs_timer_period_ms));
nwritten = vfs_write(curlun->filp,
(char __user *)bh->buf,
amount, &file_offset_tmp);
del_timer_sync(&common->vfs_timer);
VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
(unsigned long long)file_offset, (int)nwritten);
diff = ktime_sub(ktime_get(), start);
curlun->perf.wbytes += nwritten;
curlun->perf.wtime =
ktime_add(curlun->perf.wtime, diff);
if (signal_pending(current))
return -EINTR; /* Interrupted! */
if (nwritten < 0) {
LDBG(curlun, "error in file write: %d\n",
(int)nwritten);
nwritten = 0;
} else if (nwritten < amount) {
LDBG(curlun, "partial file write: %d/%u\n",
(int)nwritten, amount);
nwritten = round_down(nwritten, curlun->blksize);
}
file_offset += nwritten;
amount_left_to_write -= nwritten;
common->residue -= nwritten;
/* If an error occurred, report it and its position */
if (nwritten < amount) {
curlun->sense_data = SS_WRITE_ERROR;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
write_error_after_csw_sent = 1;
goto write_error;
break;
}
write_error:
if ((nwritten == amount) && !csw_sent) {
if (write_error_after_csw_sent)
break;
/*
* If residue still exists and nothing left to
* write, device must send correct residue to
* host in this case.
*/
if (!amount_left_to_write && common->residue) {
must_report_residue = 1;
break;
}
/*
* Check if any of the buffer is in the
* busy state, if any buffer is in busy state,
* means the complete data is not received
* yet from the host. So there is no point in
* csw right away without the complete data.
*/
for (i = 0; i < common->fsg_num_buffers; i++) {
if (common->buffhds[i].state ==
BUF_STATE_BUSY)
break;
}
if (!amount_left_to_req &&
i == common->fsg_num_buffers) {
csw_sent = 1;
send_status(common);
}
}
empty_write:
/* Did the host decide to stop early? */
if (bh->outreq->actual < bh->bulk_out_intended_length) {
common->short_packet_received = 1;
break;
}
continue;
}
/* Wait for something to happen */
rc = sleep_thread(common, false);
if (rc)
return rc;
}
return -EIO; /* No default reply */
}
/*-------------------------------------------------------------------------*/
static int do_synchronize_cache(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
int rc;
/* We ignore the requested LBA and write out all file's
* dirty data buffers. */
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(msc_vfs_timer_period_ms));
rc = fsg_lun_fsync_sub(curlun);
if (rc)
curlun->sense_data = SS_WRITE_ERROR;
del_timer_sync(&common->vfs_timer);
return 0;
}
/*-------------------------------------------------------------------------*/
static void invalidate_sub(struct fsg_lun *curlun)
{
struct file *filp = curlun->filp;
struct inode *inode = file_inode(filp);
unsigned long rc;
rc = invalidate_mapping_pages(inode->i_mapping, 0, -1);
VLDBG(curlun, "invalidate_mapping_pages -> %ld\n", rc);
}
static int do_verify(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
u32 lba;
u32 verification_length;
struct fsg_buffhd *bh = common->next_buffhd_to_fill;
loff_t file_offset, file_offset_tmp;
u32 amount_left;
unsigned int amount;
ssize_t nread;
/*
* Get the starting Logical Block Address and check that it's
* not too big.
*/
lba = get_unaligned_be32(&common->cmnd[2]);
if (lba >= curlun->num_sectors) {
curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
return -EINVAL;
}
/*
* We allow DPO (Disable Page Out = don't save data in the
* cache) but we don't implement it.
*/
if (common->cmnd[1] & ~0x10) {
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
verification_length = get_unaligned_be16(&common->cmnd[7]);
if (unlikely(verification_length == 0))
return -EIO; /* No default reply */
/* Prepare to carry out the file verify */
amount_left = verification_length << curlun->blkbits;
file_offset = ((loff_t) lba) << curlun->blkbits;
/* Write out all the dirty buffers before invalidating them */
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(msc_vfs_timer_period_ms));
fsg_lun_fsync_sub(curlun);
del_timer_sync(&common->vfs_timer);
if (signal_pending(current))
return -EINTR;
invalidate_sub(curlun);
if (signal_pending(current))
return -EINTR;
/* Just try to read the requested blocks */
while (amount_left > 0) {
/*
* Figure out how much we need to read:
* Try to read the remaining amount, but not more than
* the buffer size.
* And don't try to read past the end of the file.
*/
amount = min(amount_left, FSG_BUFLEN);
amount = min((loff_t)amount,
curlun->file_length - file_offset);
if (amount == 0) {
curlun->sense_data =
SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
break;
}
/* Perform the read */
file_offset_tmp = file_offset;
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(msc_vfs_timer_period_ms));
nread = vfs_read(curlun->filp,
(char __user *) bh->buf,
amount, &file_offset_tmp);
del_timer_sync(&common->vfs_timer);
VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
(unsigned long long) file_offset,
(int) nread);
if (signal_pending(current))
return -EINTR;
if (nread < 0) {
LDBG(curlun, "error in file verify: %d\n", (int)nread);
nread = 0;
} else if (nread < amount) {
LDBG(curlun, "partial file verify: %d/%u\n",
(int)nread, amount);
nread = round_down(nread, curlun->blksize);
}
if (nread == 0) {
curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
break;
}
file_offset += nread;
amount_left -= nread;
}
return 0;
}
/*-------------------------------------------------------------------------*/
static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
u8 *buf = (u8 *) bh->buf;
if (!curlun) { /* Unsupported LUNs are okay */
common->bad_lun_okay = 1;
memset(buf, 0, 36);
buf[0] = 0x7f; /* Unsupported, no device-type */
buf[4] = 31; /* Additional length */
return 36;
}
buf[0] = curlun->cdrom ? TYPE_ROM : TYPE_DISK;
buf[1] = curlun->removable ? 0x80 : 0;
buf[2] = 2; /* ANSI SCSI level 2 */
buf[3] = 2; /* SCSI-2 INQUIRY data format */
buf[4] = 31; /* Additional length */
buf[5] = 0; /* No special options */
buf[6] = 0;
buf[7] = 0;
memcpy(buf + 8, common->inquiry_string, sizeof common->inquiry_string);
return 36;
}
static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
u8 *buf = (u8 *) bh->buf;
u32 sd, sdinfo;
int valid;
/*
* From the SCSI-2 spec., section 7.9 (Unit attention condition):
*
* If a REQUEST SENSE command is received from an initiator
* with a pending unit attention condition (before the target
* generates the contingent allegiance condition), then the
* target shall either:
* a) report any pending sense data and preserve the unit
* attention condition on the logical unit, or,
* b) report the unit attention condition, may discard any
* pending sense data, and clear the unit attention
* condition on the logical unit for that initiator.
*
* FSG normally uses option a); enable this code to use option b).
*/
#if 0
if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
curlun->sense_data = curlun->unit_attention_data;
curlun->unit_attention_data = SS_NO_SENSE;
}
#endif
if (!curlun) { /* Unsupported LUNs are okay */
common->bad_lun_okay = 1;
sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
sdinfo = 0;
valid = 0;
} else {
sd = curlun->sense_data;
sdinfo = curlun->sense_data_info;
valid = curlun->info_valid << 7;
curlun->sense_data = SS_NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
memset(buf, 0, 18);
buf[0] = valid | 0x70; /* Valid, current error */
buf[2] = SK(sd);
put_unaligned_be32(sdinfo, &buf[3]); /* Sense information */
buf[7] = 18 - 8; /* Additional sense length */
buf[12] = ASC(sd);
buf[13] = ASCQ(sd);
return 18;
}
static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
u32 lba = get_unaligned_be32(&common->cmnd[2]);
int pmi = common->cmnd[8];
u8 *buf = (u8 *)bh->buf;
/* Check the PMI and LBA fields */
if (pmi > 1 || (pmi == 0 && lba != 0)) {
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
put_unaligned_be32(curlun->num_sectors - 1, &buf[0]);
/* Max logical block */
put_unaligned_be32(curlun->blksize, &buf[4]);/* Block length */
return 8;
}
static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
int msf = common->cmnd[1] & 0x02;
u32 lba = get_unaligned_be32(&common->cmnd[2]);
u8 *buf = (u8 *)bh->buf;
if (common->cmnd[1] & ~0x02) { /* Mask away MSF */
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
if (lba >= curlun->num_sectors) {
curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
return -EINVAL;
}
memset(buf, 0, 8);
buf[0] = 0x01; /* 2048 bytes of user data, rest is EC */
store_cdrom_address(&buf[4], msf, lba);
return 8;
}
static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
int msf = common->cmnd[1] & 0x02;
int start_track = common->cmnd[6];
u8 *buf = (u8 *)bh->buf;
if ((common->cmnd[1] & ~0x02) != 0 || /* Mask away MSF */
start_track > 1) {
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
memset(buf, 0, 20);
buf[1] = (20-2); /* TOC data length */
buf[2] = 1; /* First track number */
buf[3] = 1; /* Last track number */
buf[5] = 0x16; /* Data track, copying allowed */
buf[6] = 0x01; /* Only track is number 1 */
store_cdrom_address(&buf[8], msf, 0);
buf[13] = 0x16; /* Lead-out track is data */
buf[14] = 0xAA; /* Lead-out track number */
store_cdrom_address(&buf[16], msf, curlun->num_sectors);
return 20;
}
static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
int mscmnd = common->cmnd[0];
u8 *buf = (u8 *) bh->buf;
u8 *buf0 = buf;
int pc, page_code;
int changeable_values, all_pages;
int valid_page = 0;
int len, limit;
if ((common->cmnd[1] & ~0x08) != 0) { /* Mask away DBD */
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
pc = common->cmnd[2] >> 6;
page_code = common->cmnd[2] & 0x3f;
if (pc == 3) {
curlun->sense_data = SS_SAVING_PARAMETERS_NOT_SUPPORTED;
return -EINVAL;
}
changeable_values = (pc == 1);
all_pages = (page_code == 0x3f);
/*
* Write the mode parameter header. Fixed values are: default
* medium type, no cache control (DPOFUA), and no block descriptors.
* The only variable value is the WriteProtect bit. We will fill in
* the mode data length later.
*/
memset(buf, 0, 8);
if (mscmnd == MODE_SENSE) {
buf[2] = (curlun->ro ? 0x80 : 0x00); /* WP, DPOFUA */
buf += 4;
limit = 255;
} else { /* MODE_SENSE_10 */
buf[3] = (curlun->ro ? 0x80 : 0x00); /* WP, DPOFUA */
buf += 8;
limit = 65535; /* Should really be FSG_BUFLEN */
}
/* No block descriptors */
/*
* The mode pages, in numerical order. The only page we support
* is the Caching page.
*/
if (page_code == 0x08 || all_pages) {
valid_page = 1;
buf[0] = 0x08; /* Page code */
buf[1] = 10; /* Page length */
memset(buf+2, 0, 10); /* None of the fields are changeable */
if (!changeable_values) {
buf[2] = 0x04; /* Write cache enable, */
/* Read cache not disabled */
/* No cache retention priorities */
put_unaligned_be16(0xffff, &buf[4]);
/* Don't disable prefetch */
/* Minimum prefetch = 0 */
put_unaligned_be16(0xffff, &buf[8]);
/* Maximum prefetch */
put_unaligned_be16(0xffff, &buf[10]);
/* Maximum prefetch ceiling */
}
buf += 12;
}
/*
* Check that a valid page was requested and the mode data length
* isn't too long.
*/
len = buf - buf0;
if (!valid_page || len > limit) {
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
/* Store the mode data length */
if (mscmnd == MODE_SENSE)
buf0[0] = len - 1;
else
put_unaligned_be16(len - 2, buf0);
return len;
}
static int do_start_stop(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
int loej, start;
if (!curlun) {
return -EINVAL;
} else if (!curlun->removable) {
curlun->sense_data = SS_INVALID_COMMAND;
return -EINVAL;
} else if ((common->cmnd[1] & ~0x01) != 0 || /* Mask away Immed */
(common->cmnd[4] & ~0x03) != 0) { /* Mask LoEj, Start */
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
loej = common->cmnd[4] & 0x02;
start = common->cmnd[4] & 0x01;
/*
* Our emulation doesn't support mounting; the medium is
* available for use as soon as it is loaded.
*/
if (start) {
if (!fsg_lun_is_open(curlun)) {
curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
return -EINVAL;
}
return 0;
}
/* Are we allowed to unload the media? */
if (curlun->prevent_medium_removal) {
LDBG(curlun, "unload attempt prevented\n");
curlun->sense_data = SS_MEDIUM_REMOVAL_PREVENTED;
return -EINVAL;
}
if (!loej)
return 0;
up_read(&common->filesem);
down_write(&common->filesem);
fsg_lun_close(curlun);
up_write(&common->filesem);
down_read(&common->filesem);
return 0;
}
static int do_prevent_allow(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
int prevent;
if (!common->curlun) {
return -EINVAL;
} else if (!common->curlun->removable) {
common->curlun->sense_data = SS_INVALID_COMMAND;
return -EINVAL;
}
prevent = common->cmnd[4] & 0x01;
if ((common->cmnd[4] & ~0x01) != 0) { /* Mask away Prevent */
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
if (!curlun->nofua && curlun->prevent_medium_removal && !prevent) {
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(msc_vfs_timer_period_ms));
fsg_lun_fsync_sub(curlun);
del_timer_sync(&common->vfs_timer);
}
curlun->prevent_medium_removal = prevent;
return 0;
}
static int do_read_format_capacities(struct fsg_common *common,
struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
u8 *buf = (u8 *) bh->buf;
buf[0] = buf[1] = buf[2] = 0;
buf[3] = 8; /* Only the Current/Maximum Capacity Descriptor */
buf += 4;
put_unaligned_be32(curlun->num_sectors, &buf[0]);
/* Number of blocks */
put_unaligned_be32(curlun->blksize, &buf[4]);/* Block length */
buf[4] = 0x02; /* Current capacity */
return 12;
}
static int do_mode_select(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
/* We don't support MODE SELECT */
if (curlun)
curlun->sense_data = SS_INVALID_COMMAND;
return -EINVAL;
}
/*-------------------------------------------------------------------------*/
static int halt_bulk_in_endpoint(struct fsg_dev *fsg)
{
int rc;
rc = fsg_set_halt(fsg, fsg->bulk_in);
if (rc == -EAGAIN)
VDBG(fsg, "delayed bulk-in endpoint halt\n");
while (rc != 0) {
if (rc != -EAGAIN) {
WARNING(fsg, "usb_ep_set_halt -> %d\n", rc);
rc = 0;
break;
}
/* Wait for a short time and then try again */
if (msleep_interruptible(100) != 0)
return -EINTR;
rc = usb_ep_set_halt(fsg->bulk_in);
}
return rc;
}
static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
{
int rc;
DBG(fsg, "bulk-in set wedge\n");
rc = usb_ep_set_wedge(fsg->bulk_in);
if (rc == -EAGAIN)
VDBG(fsg, "delayed bulk-in endpoint wedge\n");
while (rc != 0) {
if (rc != -EAGAIN) {
WARNING(fsg, "usb_ep_set_wedge -> %d\n", rc);
rc = 0;
break;
}
/* Wait for a short time and then try again */
if (msleep_interruptible(100) != 0)
return -EINTR;
rc = usb_ep_set_wedge(fsg->bulk_in);
}
return rc;
}
static int throw_away_data(struct fsg_common *common)
{
struct fsg_buffhd *bh;
u32 amount;
int rc;
for (bh = common->next_buffhd_to_drain;
bh->state != BUF_STATE_EMPTY || common->usb_amount_left > 0;
bh = common->next_buffhd_to_drain) {
/* Throw away the data in a filled buffer */
if (bh->state == BUF_STATE_FULL) {
smp_rmb();
bh->state = BUF_STATE_EMPTY;
common->next_buffhd_to_drain = bh->next;
/* A short packet or an error ends everything */
if (bh->outreq->actual < bh->bulk_out_intended_length ||
bh->outreq->status != 0) {
raise_exception(common,
FSG_STATE_ABORT_BULK_OUT);
return -EINTR;
}
continue;
}
/* Try to submit another request if we need one */
bh = common->next_buffhd_to_fill;
if (bh->state == BUF_STATE_EMPTY
&& common->usb_amount_left > 0) {
amount = min(common->usb_amount_left, FSG_BUFLEN);
/*
* Except at the end of the transfer, amount will be
* equal to the buffer size, which is divisible by
* the bulk-out maxpacket size.
*/
set_bulk_out_req_length(common, bh, amount);
if (!start_out_transfer(common, bh))
/* Dunno what to do if common->fsg is NULL */
return -EIO;
common->next_buffhd_to_fill = bh->next;
common->usb_amount_left -= amount;
continue;
}
/* Otherwise wait for something to happen */
rc = sleep_thread(common, true);
if (rc)
return rc;
}
return 0;
}
static int finish_reply(struct fsg_common *common)
{
struct fsg_buffhd *bh = common->next_buffhd_to_fill;
int rc = 0;
switch (common->data_dir) {
case DATA_DIR_NONE:
break; /* Nothing to send */
/*
* If we don't know whether the host wants to read or write,
* this must be CB or CBI with an unknown command. We mustn't
* try to send or receive any data. So stall both bulk pipes
* if we can and wait for a reset.
*/
case DATA_DIR_UNKNOWN:
if (!common->can_stall) {
/* Nothing */
} else if (fsg_is_set(common)) {
fsg_set_halt(common->fsg, common->fsg->bulk_out);
rc = halt_bulk_in_endpoint(common->fsg);
} else {
/* Don't know what to do if common->fsg is NULL */
rc = -EIO;
}
break;
/* All but the last buffer of data must have already been sent */
case DATA_DIR_TO_HOST:
if (common->data_size == 0) {
/* Nothing to send */
/* Don't know what to do if common->fsg is NULL */
} else if (!fsg_is_set(common)) {
rc = -EIO;
/* If there's no residue, simply send the last buffer */
} else if (common->residue == 0) {
bh->inreq->zero = 0;
if (!start_in_transfer(common, bh))
return -EIO;
common->next_buffhd_to_fill = bh->next;
/*
* For Bulk-only, mark the end of the data with a short
* packet. If we are allowed to stall, halt the bulk-in
* endpoint. (Note: This violates the Bulk-Only Transport
* specification, which requires us to pad the data if we
* don't halt the endpoint. Presumably nobody will mind.)
*/
} else {
bh->inreq->zero = 1;
if (!start_in_transfer(common, bh))
rc = -EIO;
common->next_buffhd_to_fill = bh->next;
if (common->can_stall)
rc = halt_bulk_in_endpoint(common->fsg);
}
break;
/*
* We have processed all we want from the data the host has sent.
* There may still be outstanding bulk-out requests.
*/
case DATA_DIR_FROM_HOST:
if (common->residue == 0) {
/* Nothing to receive */
/* Did the host stop sending unexpectedly early? */
} else if (common->short_packet_received) {
raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
rc = -EINTR;
/*
* We haven't processed all the incoming data. Even though
* we may be allowed to stall, doing so would cause a race.
* The controller may already have ACK'ed all the remaining
* bulk-out packets, in which case the host wouldn't see a
* STALL. Not realizing the endpoint was halted, it wouldn't
* clear the halt -- leading to problems later on.
*/
#if 0
} else if (common->can_stall) {
if (fsg_is_set(common))
fsg_set_halt(common->fsg,
common->fsg->bulk_out);
raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
rc = -EINTR;
#endif
/*
* We can't stall. Read in the excess data and throw it
* all away.
*/
} else {
rc = throw_away_data(common);
}
break;
}
return rc;
}
static int send_status(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
struct fsg_buffhd *bh;
struct bulk_cs_wrap *csw;
int rc;
u8 status = US_BULK_STAT_OK;
u32 sd, sdinfo = 0;
/* Wait for the next buffer to become available */
spin_lock_irq(&common->lock);
bh = common->next_buffhd_to_fill;
while (bh->state != BUF_STATE_EMPTY) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, true);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
if (curlun) {
sd = curlun->sense_data;
sdinfo = curlun->sense_data_info;
} else if (common->bad_lun_okay)
sd = SS_NO_SENSE;
else
sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
if (common->phase_error) {
DBG(common, "sending phase-error status\n");
status = US_BULK_STAT_PHASE;
sd = SS_INVALID_COMMAND;
} else if (sd != SS_NO_SENSE) {
DBG(common, "sending command-failure status\n");
status = US_BULK_STAT_FAIL;
VDBG(common, " sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
" info x%x\n",
SK(sd), ASC(sd), ASCQ(sd), sdinfo);
}
/* Store and send the Bulk-only CSW */
csw = (void *)bh->buf;
csw->Signature = cpu_to_le32(US_BULK_CS_SIGN);
csw->Tag = common->tag;
csw->Residue = cpu_to_le32(common->residue);
/*
* Since csw is being sent early, before
* writing on to storage media, need to set
* residue to zero,assuming that write will succeed.
*/
if (write_error_after_csw_sent || must_report_residue) {
write_error_after_csw_sent = 0;
must_report_residue = 0;
}
else
csw->Residue = 0;
csw->Status = status;
bh->inreq->length = US_BULK_CS_WRAP_LEN;
bh->inreq->zero = 0;
if (!start_in_transfer(common, bh))
/* Don't know what to do if common->fsg is NULL */
return -EIO;
common->next_buffhd_to_fill = bh->next;
return 0;
}
/*-------------------------------------------------------------------------*/
/*
* Check whether the command is properly formed and whether its data size
* and direction agree with the values we already have.
*/
static int check_command(struct fsg_common *common, int cmnd_size,
enum data_direction data_dir, unsigned int mask,
int needs_medium, const char *name)
{
int i;
unsigned int lun = common->cmnd[1] >> 5;
static const char dirletter[4] = {'u', 'o', 'i', 'n'};
char hdlen[20];
struct fsg_lun *curlun;
hdlen[0] = 0;
if (common->data_dir != DATA_DIR_UNKNOWN)
sprintf(hdlen, ", H%c=%u", dirletter[(int) common->data_dir],
common->data_size);
VDBG(common, "SCSI command: %s; Dc=%d, D%c=%u; Hc=%d%s\n",
name, cmnd_size, dirletter[(int) data_dir],
common->data_size_from_cmnd, common->cmnd_size, hdlen);
/*
* We can't reply at all until we know the correct data direction
* and size.
*/
if (common->data_size_from_cmnd == 0)
data_dir = DATA_DIR_NONE;
if (common->data_size < common->data_size_from_cmnd) {
/*
* Host data size < Device data size is a phase error.
* Carry out the command, but only transfer as much as
* we are allowed.
*/
common->data_size_from_cmnd = common->data_size;
common->phase_error = 1;
}
common->residue = common->data_size;
common->usb_amount_left = common->data_size;
/* Conflicting data directions is a phase error */
if (common->data_dir != data_dir && common->data_size_from_cmnd > 0) {
common->phase_error = 1;
return -EINVAL;
}
/* Verify the length of the command itself */
if (cmnd_size != common->cmnd_size) {
/*
* Special case workaround: There are plenty of buggy SCSI
* implementations. Many have issues with cbw->Length
* field passing a wrong command size. For those cases we
* always try to work around the problem by using the length
* sent by the host side provided it is at least as large
* as the correct command length.
* Examples of such cases would be MS-Windows, which issues
* REQUEST SENSE with cbw->Length == 12 where it should
* be 6, and xbox360 issuing INQUIRY, TEST UNIT READY and
* REQUEST SENSE with cbw->Length == 10 where it should
* be 6 as well.
*/
if (cmnd_size <= common->cmnd_size) {
DBG(common, "%s is buggy! Expected length %d "
"but we got %d\n", name,
cmnd_size, common->cmnd_size);
cmnd_size = common->cmnd_size;
} else {
common->phase_error = 1;
return -EINVAL;
}
}
/* Check that the LUN values are consistent */
if (common->lun != lun)
DBG(common, "using LUN %u from CBW, not LUN %u from CDB\n",
common->lun, lun);
/* Check the LUN */
curlun = common->curlun;
if (curlun) {
if (common->cmnd[0] != REQUEST_SENSE) {
curlun->sense_data = SS_NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
} else {
common->bad_lun_okay = 0;
/*
* INQUIRY and REQUEST SENSE commands are explicitly allowed
* to use unsupported LUNs; all others may not.
*/
if (common->cmnd[0] != INQUIRY &&
common->cmnd[0] != REQUEST_SENSE) {
DBG(common, "unsupported LUN %u\n", common->lun);
return -EINVAL;
}
}
/*
* If a unit attention condition exists, only INQUIRY and
* REQUEST SENSE commands are allowed; anything else must fail.
*/
if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
common->cmnd[0] != INQUIRY &&
common->cmnd[0] != REQUEST_SENSE) {
curlun->sense_data = curlun->unit_attention_data;
curlun->unit_attention_data = SS_NO_SENSE;
return -EINVAL;
}
/* Check that only command bytes listed in the mask are non-zero */
common->cmnd[1] &= 0x1f; /* Mask away the LUN */
for (i = 1; i < cmnd_size; ++i) {
if (common->cmnd[i] && !(mask & (1 << i))) {
if (curlun)
curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
return -EINVAL;
}
}
/* If the medium isn't mounted and the command needs to access
* it, return an error. */
if (curlun && !fsg_lun_is_open(curlun) && needs_medium) {
curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
return -EINVAL;
}
return 0;
}
/* wrapper of check_command for data size in blocks handling */
static int check_command_size_in_blocks(struct fsg_common *common,
int cmnd_size, enum data_direction data_dir,
unsigned int mask, int needs_medium, const char *name)
{
if (common->curlun)
common->data_size_from_cmnd <<= common->curlun->blkbits;
return check_command(common, cmnd_size, data_dir,
mask, needs_medium, name);
}
static int do_scsi_command(struct fsg_common *common)
{
struct fsg_buffhd *bh;
int rc;
int reply = -EINVAL;
int i;
static char unknown[16];
dump_cdb(common);
/* Wait for the next buffer to become available for data or status */
spin_lock_irq(&common->lock);
bh = common->next_buffhd_to_fill;
common->next_buffhd_to_drain = bh;
while (bh->state != BUF_STATE_EMPTY) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, true);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
common->phase_error = 0;
common->short_packet_received = 0;
down_read(&common->filesem); /* We're using the backing file */
switch (common->cmnd[0]) {
case INQUIRY:
common->data_size_from_cmnd = common->cmnd[4];
reply = check_command(common, 6, DATA_DIR_TO_HOST,
(1<<4), 0,
"INQUIRY");
if (reply == 0)
reply = do_inquiry(common, bh);
break;
case MODE_SELECT:
common->data_size_from_cmnd = common->cmnd[4];
reply = check_command(common, 6, DATA_DIR_FROM_HOST,
(1<<1) | (1<<4), 0,
"MODE SELECT(6)");
if (reply == 0)
reply = do_mode_select(common, bh);
break;
case MODE_SELECT_10:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_FROM_HOST,
(1<<1) | (3<<7), 0,
"MODE SELECT(10)");
if (reply == 0)
reply = do_mode_select(common, bh);
break;
case MODE_SENSE:
common->data_size_from_cmnd = common->cmnd[4];
reply = check_command(common, 6, DATA_DIR_TO_HOST,
(1<<1) | (1<<2) | (1<<4), 0,
"MODE SENSE(6)");
if (reply == 0)
reply = do_mode_sense(common, bh);
break;
case MODE_SENSE_10:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(1<<1) | (1<<2) | (3<<7), 0,
"MODE SENSE(10)");
if (reply == 0)
reply = do_mode_sense(common, bh);
break;
case ALLOW_MEDIUM_REMOVAL:
common->data_size_from_cmnd = 0;
reply = check_command(common, 6, DATA_DIR_NONE,
(1<<4), 0,
"PREVENT-ALLOW MEDIUM REMOVAL");
if (reply == 0)
reply = do_prevent_allow(common);
break;
case READ_6:
i = common->cmnd[4];
common->data_size_from_cmnd = (i == 0) ? 256 : i;
reply = check_command_size_in_blocks(common, 6,
DATA_DIR_TO_HOST,
(7<<1) | (1<<4), 1,
"READ(6)");
if (reply == 0)
reply = do_read(common);
break;
case READ_10:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command_size_in_blocks(common, 10,
DATA_DIR_TO_HOST,
(1<<1) | (0xf<<2) | (3<<7), 1,
"READ(10)");
if (reply == 0)
reply = do_read(common);
break;
case READ_12:
common->data_size_from_cmnd =
get_unaligned_be32(&common->cmnd[6]);
reply = check_command_size_in_blocks(common, 12,
DATA_DIR_TO_HOST,
(1<<1) | (0xf<<2) | (0xf<<6), 1,
"READ(12)");
if (reply == 0)
reply = do_read(common);
break;
case READ_CAPACITY:
common->data_size_from_cmnd = 8;
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(0xf<<2) | (1<<8), 1,
"READ CAPACITY");
if (reply == 0)
reply = do_read_capacity(common, bh);
break;
case READ_HEADER:
if (!common->curlun || !common->curlun->cdrom)
goto unknown_cmnd;
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(3<<7) | (0x1f<<1), 1,
"READ HEADER");
if (reply == 0)
reply = do_read_header(common, bh);
break;
case READ_TOC:
if (!common->curlun || !common->curlun->cdrom)
goto unknown_cmnd;
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(7<<6) | (1<<1), 1,
"READ TOC");
if (reply == 0)
reply = do_read_toc(common, bh);
break;
case READ_FORMAT_CAPACITIES:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(3<<7), 1,
"READ FORMAT CAPACITIES");
if (reply == 0)
reply = do_read_format_capacities(common, bh);
break;
case REQUEST_SENSE:
common->data_size_from_cmnd = common->cmnd[4];
reply = check_command(common, 6, DATA_DIR_TO_HOST,
(1<<4), 0,
"REQUEST SENSE");
if (reply == 0)
reply = do_request_sense(common, bh);
break;
case START_STOP:
common->data_size_from_cmnd = 0;
reply = check_command(common, 6, DATA_DIR_NONE,
(1<<1) | (1<<4), 0,
"START-STOP UNIT");
if (reply == 0)
reply = do_start_stop(common);
break;
case SYNCHRONIZE_CACHE:
common->data_size_from_cmnd = 0;
reply = check_command(common, 10, DATA_DIR_NONE,
(0xf<<2) | (3<<7), 1,
"SYNCHRONIZE CACHE");
if (reply == 0)
reply = do_synchronize_cache(common);
break;
case TEST_UNIT_READY:
common->data_size_from_cmnd = 0;
reply = check_command(common, 6, DATA_DIR_NONE,
0, 1,
"TEST UNIT READY");
break;
/*
* Although optional, this command is used by MS-Windows. We
* support a minimal version: BytChk must be 0.
*/
case VERIFY:
common->data_size_from_cmnd = 0;
reply = check_command(common, 10, DATA_DIR_NONE,
(1<<1) | (0xf<<2) | (3<<7), 1,
"VERIFY");
if (reply == 0)
reply = do_verify(common);
break;
case WRITE_6:
i = common->cmnd[4];
common->data_size_from_cmnd = (i == 0) ? 256 : i;
reply = check_command_size_in_blocks(common, 6,
DATA_DIR_FROM_HOST,
(7<<1) | (1<<4), 1,
"WRITE(6)");
if (reply == 0)
reply = do_write(common);
break;
case WRITE_10:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command_size_in_blocks(common, 10,
DATA_DIR_FROM_HOST,
(1<<1) | (0xf<<2) | (3<<7), 1,
"WRITE(10)");
if (reply == 0)
reply = do_write(common);
break;
case WRITE_12:
common->data_size_from_cmnd =
get_unaligned_be32(&common->cmnd[6]);
reply = check_command_size_in_blocks(common, 12,
DATA_DIR_FROM_HOST,
(1<<1) | (0xf<<2) | (0xf<<6), 1,
"WRITE(12)");
if (reply == 0)
reply = do_write(common);
break;
/*
* Some mandatory commands that we recognize but don't implement.
* They don't mean much in this setting. It's left as an exercise
* for anyone interested to implement RESERVE and RELEASE in terms
* of Posix locks.
*/
case FORMAT_UNIT:
case RELEASE:
case RESERVE:
case SEND_DIAGNOSTIC:
/* Fall through */
default:
unknown_cmnd:
common->data_size_from_cmnd = 0;
sprintf(unknown, "Unknown x%02x", common->cmnd[0]);
reply = check_command(common, common->cmnd_size,
DATA_DIR_UNKNOWN, ~0, 0, unknown);
if (reply == 0) {
common->curlun->sense_data = SS_INVALID_COMMAND;
reply = -EINVAL;
}
break;
}
up_read(&common->filesem);
if (reply == -EINTR || signal_pending(current))
return -EINTR;
/* Set up the single reply buffer for finish_reply() */
if (reply == -EINVAL)
reply = 0; /* Error reply length */
if (reply >= 0 && common->data_dir == DATA_DIR_TO_HOST) {
reply = min((u32)reply, common->data_size_from_cmnd);
bh->inreq->length = reply;
bh->state = BUF_STATE_FULL;
common->residue -= reply;
} /* Otherwise it's already set */
return 0;
}
/*-------------------------------------------------------------------------*/
static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
{
struct usb_request *req = bh->outreq;
struct bulk_cb_wrap *cbw = req->buf;
struct fsg_common *common = fsg->common;
/* Was this a real packet? Should it be ignored? */
if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
return -EINVAL;
/* Is the CBW valid? */
if (req->actual != US_BULK_CB_WRAP_LEN ||
cbw->Signature != cpu_to_le32(
US_BULK_CB_SIGN)) {
DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
req->actual,
le32_to_cpu(cbw->Signature));
/*
* The Bulk-only spec says we MUST stall the IN endpoint
* (6.6.1), so it's unavoidable. It also says we must
* retain this state until the next reset, but there's
* no way to tell the controller driver it should ignore
* Clear-Feature(HALT) requests.
*
* We aren't required to halt the OUT endpoint; instead
* we can simply accept and discard any data received
* until the next reset.
*/
wedge_bulk_in_endpoint(fsg);
set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
return -EINVAL;
}
/* Is the CBW meaningful? */
if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~US_BULK_FLAG_IN ||
cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
"cmdlen %u\n",
cbw->Lun, cbw->Flags, cbw->Length);
/*
* We can do anything we want here, so let's stall the
* bulk pipes if we are allowed to.
*/
if (common->can_stall) {
fsg_set_halt(fsg, fsg->bulk_out);
halt_bulk_in_endpoint(fsg);
}
return -EINVAL;
}
/* Save the command for later */
common->cmnd_size = cbw->Length;
memcpy(common->cmnd, cbw->CDB, common->cmnd_size);
if (cbw->Flags & US_BULK_FLAG_IN)
common->data_dir = DATA_DIR_TO_HOST;
else
common->data_dir = DATA_DIR_FROM_HOST;
common->data_size = le32_to_cpu(cbw->DataTransferLength);
if (common->data_size == 0)
common->data_dir = DATA_DIR_NONE;
common->lun = cbw->Lun;
if (common->lun < common->nluns)
common->curlun = common->luns[common->lun];
else
common->curlun = NULL;
common->tag = cbw->Tag;
return 0;
}
static int get_next_command(struct fsg_common *common)
{
struct fsg_buffhd *bh;
int rc = 0;
/* Wait for the next buffer to become available */
spin_lock_irq(&common->lock);
bh = common->next_buffhd_to_fill;
while (bh->state != BUF_STATE_EMPTY) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, true);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
/* Queue a request to read a Bulk-only CBW */
set_bulk_out_req_length(common, bh, US_BULK_CB_WRAP_LEN);
if (!start_out_transfer(common, bh))
/* Don't know what to do if common->fsg is NULL */
return -EIO;
/*
* We will drain the buffer in software, which means we
* can reuse it for the next filling. No need to advance
* next_buffhd_to_fill.
*/
/* Wait for the CBW to arrive */
spin_lock_irq(&common->lock);
while (bh->state != BUF_STATE_FULL) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, true);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
smp_rmb();
rc = fsg_is_set(common) ? received_cbw(common->fsg, bh) : -EIO;
spin_lock_irq(&common->lock);
bh->state = BUF_STATE_EMPTY;
spin_unlock_irq(&common->lock);
return rc;
}
/*-------------------------------------------------------------------------*/
static int alloc_request(struct fsg_common *common, struct usb_ep *ep,
struct usb_request **preq)
{
*preq = usb_ep_alloc_request(ep, GFP_ATOMIC);
if (*preq)
return 0;
ERROR(common, "can't allocate request for %s\n", ep->name);
return -ENOMEM;
}
/* Reset interface setting and re-init endpoint state (toggle etc). */
static int do_set_interface(struct fsg_common *common, struct fsg_dev *new_fsg)
{
struct fsg_dev *fsg;
int i, rc = 0;
if (common->running)
DBG(common, "reset interface\n");
reset:
/* Deallocate the requests */
if (common->fsg) {
fsg = common->fsg;
for (i = 0; i < common->fsg_num_buffers; ++i) {
struct fsg_buffhd *bh = &common->buffhds[i];
if (bh->inreq) {
usb_ep_free_request(fsg->bulk_in, bh->inreq);
bh->inreq = NULL;
}
if (bh->outreq) {
usb_ep_free_request(fsg->bulk_out, bh->outreq);
bh->outreq = NULL;
}
}
common->fsg = NULL;
wake_up(&common->fsg_wait);
}
common->running = 0;
if (!new_fsg || rc)
return rc;
common->fsg = new_fsg;
fsg = common->fsg;
/* Allocate the requests */
for (i = 0; i < common->fsg_num_buffers; ++i) {
struct fsg_buffhd *bh = &common->buffhds[i];
rc = alloc_request(common, fsg->bulk_in, &bh->inreq);
if (rc)
goto reset;
rc = alloc_request(common, fsg->bulk_out, &bh->outreq);
if (rc)
goto reset;
bh->inreq->buf = bh->outreq->buf = bh->buf;
bh->inreq->context = bh->outreq->context = bh;
bh->inreq->complete = bulk_in_complete;
bh->outreq->complete = bulk_out_complete;
}
common->running = 1;
for (i = 0; i < common->nluns; ++i)
if (common->luns[i])
common->luns[i]->unit_attention_data =
SS_RESET_OCCURRED;
return rc;
}
/****************************** ALT CONFIGS ******************************/
static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct fsg_dev *fsg = fsg_from_func(f);
struct fsg_common *common = fsg->common;
int rc;
/* Enable the endpoints */
rc = config_ep_by_speed(common->gadget, &(fsg->function), fsg->bulk_in);
if (rc)
goto err_exit;
rc = usb_ep_enable(fsg->bulk_in);
if (rc)
goto err_exit;
fsg->bulk_in->driver_data = common;
fsg->bulk_in_enabled = 1;
rc = config_ep_by_speed(common->gadget, &(fsg->function),
fsg->bulk_out);
if (rc)
goto reset_bulk_int;
rc = usb_ep_enable(fsg->bulk_out);
if (rc)
goto reset_bulk_int;
fsg->bulk_out->driver_data = common;
fsg->bulk_out_enabled = 1;
common->bulk_out_maxpacket = usb_endpoint_maxp(fsg->bulk_out->desc);
clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
csw_sent = 0;
write_error_after_csw_sent = 0;
fsg->common->new_fsg = fsg;
raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
return USB_GADGET_DELAYED_STATUS;
reset_bulk_int:
usb_ep_disable(fsg->bulk_in);
fsg->bulk_in_enabled = 0;
err_exit:
return rc;
}
static void fsg_disable(struct usb_function *f)
{
struct fsg_dev *fsg = fsg_from_func(f);
/* Disable the endpoints */
if (fsg->bulk_in_enabled) {
usb_ep_disable(fsg->bulk_in);
fsg->bulk_in->driver_data = NULL;
fsg->bulk_in_enabled = 0;
}
if (fsg->bulk_out_enabled) {
usb_ep_disable(fsg->bulk_out);
fsg->bulk_out->driver_data = NULL;
fsg->bulk_out_enabled = 0;
}
fsg->common->new_fsg = NULL;
raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
}
/*-------------------------------------------------------------------------*/
static void handle_exception(struct fsg_common *common)
{
siginfo_t info;
int i;
struct fsg_buffhd *bh;
enum fsg_state old_state;
struct fsg_lun *curlun;
unsigned int exception_req_tag;
unsigned long flags;
/*
* Clear the existing signals. Anything but SIGUSR1 is converted
* into a high-priority EXIT exception.
*/
for (;;) {
int sig =
dequeue_signal_lock(current, ¤t->blocked, &info);
if (!sig)
break;
if (sig != SIGUSR1) {
if (common->state < FSG_STATE_EXIT)
DBG(common, "Main thread exiting on signal\n");
WARN_ON(1);
pr_err("%s: signal(%d) received from PID(%d) UID(%d)\n",
__func__, sig, info.si_pid, info.si_uid);
raise_exception(common, FSG_STATE_EXIT);
}
}
/* Cancel all the pending transfers */
if (likely(common->fsg)) {
for (i = 0; i < common->fsg_num_buffers; ++i) {
bh = &common->buffhds[i];
if (bh->inreq_busy)
usb_ep_dequeue(common->fsg->bulk_in, bh->inreq);
if (bh->outreq_busy)
usb_ep_dequeue(common->fsg->bulk_out,
bh->outreq);
}
/* Wait until everything is idle */
for (;;) {
int num_active = 0;
spin_lock_irq(&common->lock);
for (i = 0; i < common->fsg_num_buffers; ++i) {
bh = &common->buffhds[i];
num_active += bh->inreq_busy + bh->outreq_busy;
}
spin_unlock_irq(&common->lock);
if (num_active == 0)
break;
if (sleep_thread(common, true))
return;
}
/* Clear out the controller's fifos */
if (common->fsg->bulk_in_enabled)
usb_ep_fifo_flush(common->fsg->bulk_in);
if (common->fsg->bulk_out_enabled)
usb_ep_fifo_flush(common->fsg->bulk_out);
}
/*
* Reset the I/O buffer states and pointers, the SCSI
* state, and the exception. Then invoke the handler.
*/
spin_lock_irqsave(&common->lock, flags);
for (i = 0; i < common->fsg_num_buffers; ++i) {
bh = &common->buffhds[i];
bh->state = BUF_STATE_EMPTY;
}
common->next_buffhd_to_fill = &common->buffhds[0];
common->next_buffhd_to_drain = &common->buffhds[0];
exception_req_tag = common->exception_req_tag;
old_state = common->state;
if (old_state == FSG_STATE_ABORT_BULK_OUT)
common->state = FSG_STATE_STATUS_PHASE;
else {
for (i = 0; i < common->nluns; ++i) {
curlun = common->luns[i];
if (!curlun)
continue;
curlun->prevent_medium_removal = 0;
curlun->sense_data = SS_NO_SENSE;
curlun->unit_attention_data = SS_NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
common->state = FSG_STATE_IDLE;
}
spin_unlock_irqrestore(&common->lock, flags);
/* Carry out any extra actions required for the exception */
switch (old_state) {
case FSG_STATE_ABORT_BULK_OUT:
send_status(common);
spin_lock_irq(&common->lock);
if (common->state == FSG_STATE_STATUS_PHASE)
common->state = FSG_STATE_IDLE;
spin_unlock_irq(&common->lock);
break;
case FSG_STATE_RESET:
/*
* In case we were forced against our will to halt a
* bulk endpoint, clear the halt now. (The SuperH UDC
* requires this.)
*/
if (!fsg_is_set(common))
break;
if (test_and_clear_bit(IGNORE_BULK_OUT,
&common->fsg->atomic_bitflags))
usb_ep_clear_halt(common->fsg->bulk_in);
if (common->ep0_req_tag == exception_req_tag) {
/* Complete the status stage */
if (common->cdev)
usb_composite_setup_continue(common->cdev);
else
ep0_queue(common);
}
/*
* Technically this should go here, but it would only be
* a waste of time. Ditto for the INTERFACE_CHANGE and
* CONFIG_CHANGE cases.
*/
/* for (i = 0; i < common->nluns; ++i) */
/* if (common->luns[i]) */
/* common->luns[i]->unit_attention_data = */
/* SS_RESET_OCCURRED; */
break;
case FSG_STATE_CONFIG_CHANGE:
do_set_interface(common, common->new_fsg);
if (common->new_fsg)
usb_composite_setup_continue(common->cdev);
break;
case FSG_STATE_EXIT:
case FSG_STATE_TERMINATED:
do_set_interface(common, NULL); /* Free resources */
spin_lock_irq(&common->lock);
common->state = FSG_STATE_TERMINATED; /* Stop the thread */
spin_unlock_irq(&common->lock);
break;
case FSG_STATE_INTERFACE_CHANGE:
case FSG_STATE_DISCONNECT:
case FSG_STATE_COMMAND_PHASE:
case FSG_STATE_DATA_PHASE:
case FSG_STATE_STATUS_PHASE:
case FSG_STATE_IDLE:
break;
}
}
/*-------------------------------------------------------------------------*/
static int fsg_main_thread(void *common_)
{
struct fsg_common *common = common_;
/*
* Allow the thread to be killed by a signal, but set the signal mask
* to block everything but INT, TERM, KILL, and USR1.
*/
allow_signal(SIGINT);
allow_signal(SIGTERM);
allow_signal(SIGKILL);
allow_signal(SIGUSR1);
/* Allow the thread to be frozen */
set_freezable();
/*
* Arrange for userspace references to be interpreted as kernel
* pointers. That way we can pass a kernel pointer to a routine
* that expects a __user pointer and it will work okay.
*/
set_fs(get_ds());
/* The main loop */
while (common->state != FSG_STATE_TERMINATED) {
if (exception_in_progress(common) || signal_pending(current)) {
handle_exception(common);
continue;
}
if (!common->running) {
sleep_thread(common, true);
continue;
}
if (get_next_command(common))
continue;
spin_lock_irq(&common->lock);
if (!exception_in_progress(common))
common->state = FSG_STATE_DATA_PHASE;
spin_unlock_irq(&common->lock);
if (do_scsi_command(common) || finish_reply(common))
continue;
spin_lock_irq(&common->lock);
if (!exception_in_progress(common))
common->state = FSG_STATE_STATUS_PHASE;
spin_unlock_irq(&common->lock);
/*
* Since status is already sent for write scsi command,
* need to skip sending status once again if it is a
* write scsi command.
*/
if (csw_sent) {
csw_sent = 0;
continue;
}
if (send_status(common))
continue;
spin_lock_irq(&common->lock);
if (!exception_in_progress(common))
common->state = FSG_STATE_IDLE;
spin_unlock_irq(&common->lock);
}
spin_lock_irq(&common->lock);
common->thread_task = NULL;
spin_unlock_irq(&common->lock);
if (!common->ops || !common->ops->thread_exits
|| common->ops->thread_exits(common) < 0) {
struct fsg_lun **curlun_it = common->luns;
unsigned i = common->nluns;
down_write(&common->filesem);
for (; i--; ++curlun_it) {
struct fsg_lun *curlun = *curlun_it;
if (!curlun || !fsg_lun_is_open(curlun))
continue;
fsg_lun_close(curlun);
curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
}
up_write(&common->filesem);
}
/* Let fsg_unbind() know the thread has exited */
complete_and_exit(&common->thread_notifier, 0);
}
/*************************** DEVICE ATTRIBUTES ***************************/
static ssize_t ro_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
return fsg_show_ro(curlun, buf);
}
static ssize_t nofua_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
return fsg_show_nofua(curlun, buf);
}
static ssize_t file_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
struct rw_semaphore *filesem = dev_get_drvdata(dev);
return fsg_show_file(curlun, filesem, buf);
}
static ssize_t ro_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
struct rw_semaphore *filesem = dev_get_drvdata(dev);
return fsg_store_ro(curlun, filesem, buf, count);
}
static ssize_t nofua_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
return fsg_store_nofua(curlun, buf, count);
}
static ssize_t file_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
struct rw_semaphore *filesem = dev_get_drvdata(dev);
return fsg_store_file(curlun, filesem, buf, count);
}
static DEVICE_ATTR_RW(ro);
static DEVICE_ATTR_RW(nofua);
static DEVICE_ATTR_RW(file);
static DEVICE_ATTR(perf, 0644, fsg_show_perf, fsg_store_perf);
static struct device_attribute dev_attr_ro_cdrom = __ATTR_RO(ro);
static struct device_attribute dev_attr_file_nonremovable = __ATTR_RO(file);
/****************************** FSG COMMON ******************************/
static void fsg_common_release(struct kref *ref);
static void fsg_lun_release(struct device *dev)
{
/* Nothing needs to be done */
}
void fsg_common_get(struct fsg_common *common)
{
kref_get(&common->ref);
}
EXPORT_SYMBOL_GPL(fsg_common_get);
void fsg_common_put(struct fsg_common *common)
{
kref_put(&common->ref, fsg_common_release);
}
EXPORT_SYMBOL_GPL(fsg_common_put);
/* check if fsg_num_buffers is within a valid range */
static inline int fsg_num_buffers_validate(unsigned int fsg_num_buffers)
{
if (fsg_num_buffers >= 2 && fsg_num_buffers <= 4)
return 0;
pr_err("fsg_num_buffers %u is out of range (%d to %d)\n",
fsg_num_buffers, 2, 4);
return -EINVAL;
}
static struct fsg_common *fsg_common_setup(struct fsg_common *common)
{
if (!common) {
common = kzalloc(sizeof(*common), GFP_KERNEL);
if (!common)
return ERR_PTR(-ENOMEM);
common->free_storage_on_release = 1;
} else {
common->free_storage_on_release = 0;
}
init_rwsem(&common->filesem);
spin_lock_init(&common->lock);
kref_init(&common->ref);
init_completion(&common->thread_notifier);
init_waitqueue_head(&common->fsg_wait);
common->state = FSG_STATE_TERMINATED;
return common;
}
void fsg_common_set_sysfs(struct fsg_common *common, bool sysfs)
{
common->sysfs = sysfs;
}
EXPORT_SYMBOL_GPL(fsg_common_set_sysfs);
static void _fsg_common_free_buffers(struct fsg_buffhd *buffhds, unsigned n)
{
if (buffhds) {
struct fsg_buffhd *bh = buffhds;
while (n--) {
kfree(bh->buf);
++bh;
}
kfree(buffhds);
}
}
int fsg_common_set_num_buffers(struct fsg_common *common, unsigned int n)
{
struct fsg_buffhd *bh, *buffhds;
int i, rc;
size_t extra_buf_alloc = 0;
if (common->gadget)
extra_buf_alloc = common->gadget->extra_buf_alloc;
rc = fsg_num_buffers_validate(n);
if (rc != 0)
return rc;
buffhds = kcalloc(n, sizeof(*buffhds), GFP_KERNEL);
if (!buffhds)
return -ENOMEM;
/* Data buffers cyclic list */
bh = buffhds;
i = n;
goto buffhds_first_it;
do {
bh->next = bh + 1;
++bh;
buffhds_first_it:
bh->buf = kmalloc(FSG_BUFLEN + extra_buf_alloc,
GFP_KERNEL);
if (unlikely(!bh->buf))
goto error_release;
} while (--i);
bh->next = buffhds;
_fsg_common_free_buffers(common->buffhds, common->fsg_num_buffers);
common->fsg_num_buffers = n;
common->buffhds = buffhds;
return 0;
error_release:
/*
* "buf"s pointed to by heads after n - i are NULL
* so releasing them won't hurt
*/
_fsg_common_free_buffers(buffhds, n);
return -ENOMEM;
}
EXPORT_SYMBOL_GPL(fsg_common_set_num_buffers);
static inline void fsg_common_remove_sysfs(struct fsg_lun *lun)
{
device_remove_file(&lun->dev, &dev_attr_nofua);
/*
* device_remove_file() =>
*
* here the attr (e.g. dev_attr_ro) is only used to be passed to:
*
* sysfs_remove_file() =>
*
* here e.g. both dev_attr_ro_cdrom and dev_attr_ro are in
* the same namespace and
* from here only attr->name is passed to:
*
* sysfs_hash_and_remove()
*
* attr->name is the same for dev_attr_ro_cdrom and
* dev_attr_ro
* attr->name is the same for dev_attr_file and
* dev_attr_file_nonremovable
*
* so we don't differentiate between removing e.g. dev_attr_ro_cdrom
* and dev_attr_ro
*/
device_remove_file(&lun->dev, &dev_attr_ro);
device_remove_file(&lun->dev, &dev_attr_file);
device_remove_file(&lun->dev, &dev_attr_perf);
}
void fsg_common_remove_lun(struct fsg_lun *lun, bool sysfs)
{
if (sysfs) {
fsg_common_remove_sysfs(lun);
device_unregister(&lun->dev);
}
fsg_lun_close(lun);
kfree(lun);
}
EXPORT_SYMBOL_GPL(fsg_common_remove_lun);
static void _fsg_common_remove_luns(struct fsg_common *common, int n)
{
int i;
for (i = 0; i < n; ++i)
if (common->luns[i]) {
fsg_common_remove_lun(common->luns[i], common->sysfs);
common->luns[i] = NULL;
}
}
EXPORT_SYMBOL_GPL(fsg_common_remove_luns);
void fsg_common_remove_luns(struct fsg_common *common)
{
_fsg_common_remove_luns(common, common->nluns);
}
void fsg_common_free_luns(struct fsg_common *common)
{
unsigned long flags;
fsg_common_remove_luns(common);
spin_lock_irqsave(&common->lock, flags);
kfree(common->luns);
common->luns = NULL;
common->nluns = 0;
spin_unlock_irqrestore(&common->lock, flags);
}
EXPORT_SYMBOL_GPL(fsg_common_free_luns);
int fsg_common_set_nluns(struct fsg_common *common, int nluns)
{
struct fsg_lun **curlun;
/* Find out how many LUNs there should be */
if (nluns < 1 || nluns > FSG_MAX_LUNS) {
pr_err("invalid number of LUNs: %u\n", nluns);
return -EINVAL;
}
curlun = kcalloc(nluns, sizeof(*curlun), GFP_KERNEL);
if (unlikely(!curlun))
return -ENOMEM;
if (common->luns)
fsg_common_free_luns(common);
common->luns = curlun;
common->nluns = nluns;
pr_info("Number of LUNs=%d\n", common->nluns);
return 0;
}
EXPORT_SYMBOL_GPL(fsg_common_set_nluns);
void fsg_common_set_ops(struct fsg_common *common,
const struct fsg_operations *ops)
{
common->ops = ops;
}
EXPORT_SYMBOL_GPL(fsg_common_set_ops);
void fsg_common_free_buffers(struct fsg_common *common)
{
_fsg_common_free_buffers(common->buffhds, common->fsg_num_buffers);
common->buffhds = NULL;
}
EXPORT_SYMBOL_GPL(fsg_common_free_buffers);
int fsg_common_set_cdev(struct fsg_common *common,
struct usb_composite_dev *cdev, bool can_stall)
{
struct usb_string *us;
common->gadget = cdev->gadget;
common->ep0 = cdev->gadget->ep0;
common->ep0req = cdev->req;
common->cdev = cdev;
us = usb_gstrings_attach(cdev, fsg_strings_array,
ARRAY_SIZE(fsg_strings));
if (IS_ERR(us))
return PTR_ERR(us);
fsg_intf_desc.iInterface = us[FSG_STRING_INTERFACE].id;
/*
* Some peripheral controllers are known not to be able to
* halt bulk endpoints correctly. If one of them is present,
* disable stalls.
*/
common->can_stall = can_stall && !(gadget_is_at91(common->gadget));
return 0;
}
EXPORT_SYMBOL_GPL(fsg_common_set_cdev);
static inline int fsg_common_add_sysfs(struct fsg_common *common,
struct fsg_lun *lun)
{
int rc;
rc = device_register(&lun->dev);
if (rc) {
put_device(&lun->dev);
return rc;
}
rc = device_create_file(&lun->dev,
lun->cdrom
? &dev_attr_ro_cdrom
: &dev_attr_ro);
if (rc)
goto error;
rc = device_create_file(&lun->dev,
lun->removable
? &dev_attr_file
: &dev_attr_file_nonremovable);
if (rc)
goto error;
rc = device_create_file(&lun->dev, &dev_attr_nofua);
if (rc)
goto error;
rc = device_create_file(&lun->dev, &dev_attr_perf);
if (rc)
pr_err("failed to create sysfs entry: %d\n", rc);
return 0;
error:
/* removing nonexistent files is a no-op */
fsg_common_remove_sysfs(lun);
device_unregister(&lun->dev);
return rc;
}
int fsg_common_create_lun(struct fsg_common *common, struct fsg_lun_config *cfg,
unsigned int id, const char *name,
const char **name_pfx)
{
struct fsg_lun *lun;
char *pathbuf, *p;
int rc = -ENOMEM;
if (!common->nluns || !common->luns)
return -ENODEV;
if (common->luns[id])
return -EBUSY;
#ifdef CONFIG_ZTEMT_USB
if (!cfg->filename && !cfg->removable && !cfg->cdrom) {
#else
if (!cfg->filename && !cfg->removable) {
#endif
pr_err("no file given for LUN%d\n", id);
return -EINVAL;
}
lun = kzalloc(sizeof(*lun), GFP_KERNEL);
if (!lun)
return -ENOMEM;
lun->name_pfx = name_pfx;
lun->cdrom = !!cfg->cdrom;
lun->ro = cfg->cdrom || cfg->ro;
lun->initially_ro = lun->ro;
lun->removable = !!cfg->removable;
if (!common->sysfs) {
/* we DON'T own the name!*/
lun->name = name;
} else {
lun->dev.release = fsg_lun_release;
lun->dev.parent = &common->gadget->dev;
dev_set_drvdata(&lun->dev, &common->filesem);
dev_set_name(&lun->dev, "%s", name);
lun->name = dev_name(&lun->dev);
rc = fsg_common_add_sysfs(common, lun);
if (rc) {
pr_info("failed to register LUN%d: %d\n", id, rc);
goto error_sysfs;
}
}
common->luns[id] = lun;
if (cfg->filename) {
rc = fsg_lun_open(lun, cfg->filename);
if (rc)
goto error_lun;
}
pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
p = "(no medium)";
if (fsg_lun_is_open(lun)) {
p = "(error)";
if (pathbuf) {
p = d_path(&lun->filp->f_path, pathbuf, PATH_MAX);
if (IS_ERR(p))
p = "(error)";
}
}
pr_info("LUN: %s%s%sfile: %s\n",
lun->removable ? "removable " : "",
lun->ro ? "read only " : "",
lun->cdrom ? "CD-ROM " : "",
p);
kfree(pathbuf);
return 0;
error_lun:
if (common->sysfs) {
fsg_common_remove_sysfs(lun);
device_unregister(&lun->dev);
}
fsg_lun_close(lun);
common->luns[id] = NULL;
error_sysfs:
kfree(lun);
return rc;
}
EXPORT_SYMBOL_GPL(fsg_common_create_lun);
int fsg_common_create_luns(struct fsg_common *common, struct fsg_config *cfg)
{
char buf[8]; /* enough for 100000000 different numbers, decimal */
int i, rc;
for (i = 0; i < common->nluns; ++i) {
snprintf(buf, sizeof(buf), "lun%d", i);
rc = fsg_common_create_lun(common, &cfg->luns[i], i, buf, NULL);
if (rc)
goto fail;
}
pr_info("Number of LUNs=%d\n", common->nluns);
return 0;
fail:
_fsg_common_remove_luns(common, i);
return rc;
}
EXPORT_SYMBOL_GPL(fsg_common_create_luns);
void fsg_common_set_inquiry_string(struct fsg_common *common, const char *vn,
const char *pn)
{
int i;
/* Prepare inquiryString */
i = get_default_bcdDevice();
snprintf(common->inquiry_string, sizeof(common->inquiry_string),
"%-8s%-16s%04x", vn ?: "Linux",
/* Assume product name dependent on the first LUN */
pn ?: ((*common->luns)->cdrom
? "File-CD Gadget"
: "File-Stor Gadget"),
i);
}
EXPORT_SYMBOL_GPL(fsg_common_set_inquiry_string);
int fsg_common_run_thread(struct fsg_common *common)
{
common->state = FSG_STATE_IDLE;
/* Tell the thread to start working */
common->thread_task =
kthread_create(fsg_main_thread, common, "file-storage");
if (IS_ERR(common->thread_task)) {
common->state = FSG_STATE_TERMINATED;
return PTR_ERR(common->thread_task);
}
DBG(common, "I/O thread pid: %d\n", task_pid_nr(common->thread_task));
wake_up_process(common->thread_task);
return 0;
}
EXPORT_SYMBOL_GPL(fsg_common_run_thread);
static void fsg_common_release(struct kref *ref)
{
struct fsg_common *common = container_of(ref, struct fsg_common, ref);
/* If the thread isn't already dead, tell it to exit now */
if (common->state != FSG_STATE_TERMINATED) {
raise_exception(common, FSG_STATE_EXIT);
wait_for_completion(&common->thread_notifier);
}
if (likely(common->luns)) {
struct fsg_lun **lun_it = common->luns;
unsigned i = common->nluns;
/* In error recovery common->nluns may be zero. */
for (; i; --i, ++lun_it) {
struct fsg_lun *lun = *lun_it;
if (!lun)
continue;
if (common->sysfs)
fsg_common_remove_sysfs(lun);
fsg_lun_close(lun);
if (common->sysfs)
device_unregister(&lun->dev);
kfree(lun);
}
kfree(common->luns);
}
_fsg_common_free_buffers(common->buffhds, common->fsg_num_buffers);
if (common->free_storage_on_release)
kfree(common);
}
int fsg_sysfs_update(struct fsg_common *common, struct device *dev, bool create)
{
int ret = 0, i;
pr_debug("%s(): common->nluns:%d\n", __func__, common->nluns);
if (create) {
for (i = 0; i < common->nluns; i++) {
if (i == 0)
snprintf(common->name[i], 8, "lun");
else
snprintf(common->name[i], 8, "lun%d", i-1);
ret = sysfs_create_link(&dev->kobj,
&common->luns[i]->dev.kobj,
common->name[i]);
if (ret) {
pr_err("%s(): failed creating sysfs:%d %s)\n",
__func__, i, common->name[i]);
goto remove_sysfs;
}
}
} else {
i = common->nluns;
goto remove_sysfs;
}
return 0;
remove_sysfs:
for (; i > 0; i--) {
pr_debug("%s(): delete sysfs for lun(id:%d)(name:%s)\n",
__func__, i, common->name[i-1]);
sysfs_remove_link(&dev->kobj, common->name[i-1]);
}
return ret;
}
EXPORT_SYMBOL(fsg_sysfs_update);
/*-------------------------------------------------------------------------*/
static int fsg_bind(struct usb_configuration *c, struct usb_function *f)
{
struct fsg_dev *fsg = fsg_from_func(f);
struct usb_gadget *gadget = c->cdev->gadget;
int i;
struct usb_ep *ep;
unsigned max_burst;
int ret;
struct fsg_opts *opts;
opts = fsg_opts_from_func_inst(f->fi);
if (!opts->no_configfs) {
ret = fsg_common_set_cdev(fsg->common, c->cdev,
fsg->common->can_stall);
if (ret)
return ret;
#ifdef CONFIG_ZTEMT_USB
fsg_common_set_inquiry_string(fsg->common, "nubia", "Android");
#else
fsg_common_set_inquiry_string(fsg->common, NULL, NULL);
#endif
ret = fsg_common_run_thread(fsg->common);
if (ret)
return ret;
}
fsg->gadget = gadget;
/* New interface */
i = usb_interface_id(c, f);
if (i < 0)
return i;
fsg_intf_desc.bInterfaceNumber = i;
fsg->interface_number = i;
/* Find all the endpoints we will use */
ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_in_desc);
if (!ep)
goto autoconf_fail;
ep->driver_data = fsg->common; /* claim the endpoint */
fsg->bulk_in = ep;
ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_out_desc);
if (!ep)
goto autoconf_fail;
ep->driver_data = fsg->common; /* claim the endpoint */
fsg->bulk_out = ep;
/* Assume endpoint addresses are the same for both speeds */
fsg_hs_bulk_in_desc.bEndpointAddress =
fsg_fs_bulk_in_desc.bEndpointAddress;
fsg_hs_bulk_out_desc.bEndpointAddress =
fsg_fs_bulk_out_desc.bEndpointAddress;
/* Calculate bMaxBurst, we know packet size is 1024 */
max_burst = min_t(unsigned, FSG_BUFLEN / 1024, 15);
fsg_ss_bulk_in_desc.bEndpointAddress =
fsg_fs_bulk_in_desc.bEndpointAddress;
fsg_ss_bulk_in_comp_desc.bMaxBurst = max_burst;
fsg_ss_bulk_out_desc.bEndpointAddress =
fsg_fs_bulk_out_desc.bEndpointAddress;
fsg_ss_bulk_out_comp_desc.bMaxBurst = max_burst;
ret = usb_assign_descriptors(f, fsg_fs_function, fsg_hs_function,
fsg_ss_function);
if (ret)
goto autoconf_fail;
return 0;
autoconf_fail:
ERROR(fsg, "unable to autoconfigure all endpoints\n");
return -ENOTSUPP;
}
/****************************** ALLOCATE FUNCTION *************************/
static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
{
struct fsg_dev *fsg = fsg_from_func(f);
struct fsg_common *common = fsg->common;
DBG(fsg, "unbind\n");
if (fsg->common->fsg == fsg) {
fsg->common->new_fsg = NULL;
raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
/* FIXME: make interruptible or killable somehow? */
wait_event(common->fsg_wait, common->fsg != fsg);
}
usb_free_all_descriptors(&fsg->function);
}
static inline struct fsg_lun_opts *to_fsg_lun_opts(struct config_item *item)
{
return container_of(to_config_group(item), struct fsg_lun_opts, group);
}
static inline struct fsg_opts *to_fsg_opts(struct config_item *item)
{
return container_of(to_config_group(item), struct fsg_opts,
func_inst.group);
}
CONFIGFS_ATTR_STRUCT(fsg_lun_opts);
CONFIGFS_ATTR_OPS(fsg_lun_opts);
static void fsg_lun_attr_release(struct config_item *item)
{
struct fsg_lun_opts *lun_opts;
lun_opts = to_fsg_lun_opts(item);
kfree(lun_opts);
}
static struct configfs_item_operations fsg_lun_item_ops = {
.release = fsg_lun_attr_release,
.show_attribute = fsg_lun_opts_attr_show,
.store_attribute = fsg_lun_opts_attr_store,
};
static ssize_t fsg_lun_opts_file_show(struct fsg_lun_opts *opts, char *page)
{
struct fsg_opts *fsg_opts;
fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
return fsg_show_file(opts->lun, &fsg_opts->common->filesem, page);
}
static ssize_t fsg_lun_opts_file_store(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
struct fsg_opts *fsg_opts;
fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
return fsg_store_file(opts->lun, &fsg_opts->common->filesem, page, len);
}
static struct fsg_lun_opts_attribute fsg_lun_opts_file =
__CONFIGFS_ATTR(file, S_IRUGO | S_IWUSR, fsg_lun_opts_file_show,
fsg_lun_opts_file_store);
static ssize_t fsg_lun_opts_ro_show(struct fsg_lun_opts *opts, char *page)
{
return fsg_show_ro(opts->lun, page);
}
static ssize_t fsg_lun_opts_ro_store(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
struct fsg_opts *fsg_opts;
fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
return fsg_store_ro(opts->lun, &fsg_opts->common->filesem, page, len);
}
static struct fsg_lun_opts_attribute fsg_lun_opts_ro =
__CONFIGFS_ATTR(ro, S_IRUGO | S_IWUSR, fsg_lun_opts_ro_show,
fsg_lun_opts_ro_store);
static ssize_t fsg_lun_opts_removable_show(struct fsg_lun_opts *opts,
char *page)
{
return fsg_show_removable(opts->lun, page);
}
static ssize_t fsg_lun_opts_removable_store(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
return fsg_store_removable(opts->lun, page, len);
}
static struct fsg_lun_opts_attribute fsg_lun_opts_removable =
__CONFIGFS_ATTR(removable, S_IRUGO | S_IWUSR,
fsg_lun_opts_removable_show,
fsg_lun_opts_removable_store);
static ssize_t fsg_lun_opts_cdrom_show(struct fsg_lun_opts *opts, char *page)
{
return fsg_show_cdrom(opts->lun, page);
}
static ssize_t fsg_lun_opts_cdrom_store(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
struct fsg_opts *fsg_opts;
fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
return fsg_store_cdrom(opts->lun, &fsg_opts->common->filesem, page,
len);
}
static struct fsg_lun_opts_attribute fsg_lun_opts_cdrom =
__CONFIGFS_ATTR(cdrom, S_IRUGO | S_IWUSR, fsg_lun_opts_cdrom_show,
fsg_lun_opts_cdrom_store);
static ssize_t fsg_lun_opts_nofua_show(struct fsg_lun_opts *opts, char *page)
{
return fsg_show_nofua(opts->lun, page);
}
static ssize_t fsg_lun_opts_nofua_store(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
return fsg_store_nofua(opts->lun, page, len);
}
static struct fsg_lun_opts_attribute fsg_lun_opts_nofua =
__CONFIGFS_ATTR(nofua, S_IRUGO | S_IWUSR, fsg_lun_opts_nofua_show,
fsg_lun_opts_nofua_store);
static struct configfs_attribute *fsg_lun_attrs[] = {
&fsg_lun_opts_file.attr,
&fsg_lun_opts_ro.attr,
&fsg_lun_opts_removable.attr,
&fsg_lun_opts_cdrom.attr,
&fsg_lun_opts_nofua.attr,
NULL,
};
static struct config_item_type fsg_lun_type = {
.ct_item_ops = &fsg_lun_item_ops,
.ct_attrs = fsg_lun_attrs,
.ct_owner = THIS_MODULE,
};
static struct config_group *fsg_lun_make(struct config_group *group,
const char *name)
{
struct fsg_lun_opts *opts;
struct fsg_opts *fsg_opts;
struct fsg_lun_config config;
char *num_str;
u8 num;
int ret;
num_str = strchr(name, '.');
if (!num_str) {
pr_err("Unable to locate . in LUN.NUMBER\n");
return ERR_PTR(-EINVAL);
}
num_str++;
ret = kstrtou8(num_str, 0, &num);
if (ret)
return ERR_PTR(ret);
fsg_opts = to_fsg_opts(&group->cg_item);
if (num >= FSG_MAX_LUNS)
return ERR_PTR(-ERANGE);
mutex_lock(&fsg_opts->lock);
if (fsg_opts->refcnt || fsg_opts->common->luns[num]) {
ret = -EBUSY;
goto out;
}
opts = kzalloc(sizeof(*opts), GFP_KERNEL);
if (!opts) {
ret = -ENOMEM;
goto out;
}
memset(&config, 0, sizeof(config));
config.removable = true;
ret = fsg_common_create_lun(fsg_opts->common, &config, num, name,
(const char **)&group->cg_item.ci_name);
if (ret) {
kfree(opts);
goto out;
}
opts->lun = fsg_opts->common->luns[num];
opts->lun_id = num;
mutex_unlock(&fsg_opts->lock);
config_group_init_type_name(&opts->group, name, &fsg_lun_type);
return &opts->group;
out:
mutex_unlock(&fsg_opts->lock);
return ERR_PTR(ret);
}
static void fsg_lun_drop(struct config_group *group, struct config_item *item)
{
struct fsg_lun_opts *lun_opts;
struct fsg_opts *fsg_opts;
lun_opts = to_fsg_lun_opts(item);
fsg_opts = to_fsg_opts(&group->cg_item);
mutex_lock(&fsg_opts->lock);
if (fsg_opts->refcnt) {
struct config_item *gadget;
gadget = group->cg_item.ci_parent->ci_parent;
unregister_gadget_item(gadget);
}
fsg_common_remove_lun(lun_opts->lun, fsg_opts->common->sysfs);
fsg_opts->common->luns[lun_opts->lun_id] = NULL;
lun_opts->lun_id = 0;
mutex_unlock(&fsg_opts->lock);
config_item_put(item);
}
CONFIGFS_ATTR_STRUCT(fsg_opts);
CONFIGFS_ATTR_OPS(fsg_opts);
static void fsg_attr_release(struct config_item *item)
{
struct fsg_opts *opts = to_fsg_opts(item);
usb_put_function_instance(&opts->func_inst);
}
static struct configfs_item_operations fsg_item_ops = {
.release = fsg_attr_release,
.show_attribute = fsg_opts_attr_show,
.store_attribute = fsg_opts_attr_store,
};
static ssize_t fsg_opts_stall_show(struct fsg_opts *opts, char *page)
{
int result;
mutex_lock(&opts->lock);
result = sprintf(page, "%d", opts->common->can_stall);
mutex_unlock(&opts->lock);
return result;
}
static ssize_t fsg_opts_stall_store(struct fsg_opts *opts, const char *page,
size_t len)
{
int ret;
bool stall;
mutex_lock(&opts->lock);
if (opts->refcnt) {
mutex_unlock(&opts->lock);
return -EBUSY;
}
ret = strtobool(page, &stall);
if (!ret) {
opts->common->can_stall = stall;
ret = len;
}
mutex_unlock(&opts->lock);
return ret;
}
static struct fsg_opts_attribute fsg_opts_stall =
__CONFIGFS_ATTR(stall, S_IRUGO | S_IWUSR, fsg_opts_stall_show,
fsg_opts_stall_store);
#ifdef CONFIG_USB_GADGET_DEBUG_FILES
static ssize_t fsg_opts_num_buffers_show(struct fsg_opts *opts, char *page)
{
int result;
mutex_lock(&opts->lock);
result = sprintf(page, "%d", opts->common->fsg_num_buffers);
mutex_unlock(&opts->lock);
return result;
}
static ssize_t fsg_opts_num_buffers_store(struct fsg_opts *opts,
const char *page, size_t len)
{
int ret;
u8 num;
mutex_lock(&opts->lock);
if (opts->refcnt) {
ret = -EBUSY;
goto end;
}
ret = kstrtou8(page, 0, &num);
if (ret)
goto end;
ret = fsg_num_buffers_validate(num);
if (ret)
goto end;
fsg_common_set_num_buffers(opts->common, num);
ret = len;
end:
mutex_unlock(&opts->lock);
return ret;
}
static struct fsg_opts_attribute fsg_opts_num_buffers =
__CONFIGFS_ATTR(num_buffers, S_IRUGO | S_IWUSR,
fsg_opts_num_buffers_show,
fsg_opts_num_buffers_store);
#endif
static struct configfs_attribute *fsg_attrs[] = {
&fsg_opts_stall.attr,
#ifdef CONFIG_USB_GADGET_DEBUG_FILES
&fsg_opts_num_buffers.attr,
#endif
NULL,
};
static struct configfs_group_operations fsg_group_ops = {
.make_group = fsg_lun_make,
.drop_item = fsg_lun_drop,
};
static struct config_item_type fsg_func_type = {
.ct_item_ops = &fsg_item_ops,
.ct_group_ops = &fsg_group_ops,
.ct_attrs = fsg_attrs,
.ct_owner = THIS_MODULE,
};
static void fsg_free_inst(struct usb_function_instance *fi)
{
struct fsg_opts *opts;
opts = fsg_opts_from_func_inst(fi);
fsg_common_put(opts->common);
kfree(opts);
}
static struct usb_function_instance *fsg_alloc_inst(void)
{
struct fsg_opts *opts;
struct fsg_lun_config config;
int rc;
opts = kzalloc(sizeof(*opts), GFP_KERNEL);
if (!opts)
return ERR_PTR(-ENOMEM);
mutex_init(&opts->lock);
opts->func_inst.free_func_inst = fsg_free_inst;
opts->common = fsg_common_setup(opts->common);
if (IS_ERR(opts->common)) {
rc = PTR_ERR(opts->common);
goto release_opts;
}
rc = fsg_common_set_nluns(opts->common, FSG_MAX_LUNS);
if (rc)
goto release_opts;
rc = fsg_common_set_num_buffers(opts->common,
CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS);
if (rc)
goto release_luns;
pr_info(FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
memset(&config, 0, sizeof(config));
config.removable = true;
rc = fsg_common_create_lun(opts->common, &config, 0, "lun.0",
(const char **)&opts->func_inst.group.cg_item.ci_name);
opts->lun0.lun = opts->common->luns[0];
opts->lun0.lun_id = 0;
config_group_init_type_name(&opts->lun0.group, "lun.0", &fsg_lun_type);
opts->default_groups[0] = &opts->lun0.group;
opts->func_inst.group.default_groups = opts->default_groups;
config_group_init_type_name(&opts->func_inst.group, "", &fsg_func_type);
return &opts->func_inst;
release_luns:
kfree(opts->common->luns);
release_opts:
kfree(opts);
return ERR_PTR(rc);
}
static void fsg_free(struct usb_function *f)
{
struct fsg_dev *fsg;
struct fsg_opts *opts;
fsg = container_of(f, struct fsg_dev, function);
opts = container_of(f->fi, struct fsg_opts, func_inst);
mutex_lock(&opts->lock);
opts->refcnt--;
mutex_unlock(&opts->lock);
kfree(fsg);
}
static struct usb_function *fsg_alloc(struct usb_function_instance *fi)
{
struct fsg_opts *opts = fsg_opts_from_func_inst(fi);
struct fsg_common *common = opts->common;
struct fsg_dev *fsg;
fsg = kzalloc(sizeof(*fsg), GFP_KERNEL);
if (unlikely(!fsg))
return ERR_PTR(-ENOMEM);
mutex_lock(&opts->lock);
opts->refcnt++;
mutex_unlock(&opts->lock);
fsg->function.name = FSG_DRIVER_DESC;
fsg->function.bind = fsg_bind;
fsg->function.unbind = fsg_unbind;
fsg->function.setup = fsg_setup;
fsg->function.set_alt = fsg_set_alt;
fsg->function.disable = fsg_disable;
fsg->function.free_func = fsg_free;
fsg->common = common;
setup_timer(&common->vfs_timer, msc_usb_vfs_timer_func,
(unsigned long) common);
return &fsg->function;
}
DECLARE_USB_FUNCTION_INIT(mass_storage, fsg_alloc_inst, fsg_alloc);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Michal Nazarewicz");
/************************* Module parameters *************************/
void fsg_config_from_params(struct fsg_config *cfg,
const struct fsg_module_parameters *params,
unsigned int fsg_num_buffers)
{
struct fsg_lun_config *lun;
unsigned i;
/* Configure LUNs */
cfg->nluns =
min(params->luns ?: (params->file_count ?: 1u),
(unsigned)FSG_MAX_LUNS);
for (i = 0, lun = cfg->luns; i < cfg->nluns; ++i, ++lun) {
lun->ro = !!params->ro[i];
lun->cdrom = !!params->cdrom[i];
lun->removable = !!params->removable[i];
lun->filename =
params->file_count > i && params->file[i][0]
? params->file[i]
: NULL;
}
/* Let MSF use defaults */
cfg->vendor_name = NULL;
cfg->product_name = NULL;
cfg->ops = NULL;
cfg->private_data = NULL;
/* Finalise */
cfg->can_stall = params->stall;
cfg->fsg_num_buffers = fsg_num_buffers;
}
EXPORT_SYMBOL_GPL(fsg_config_from_params);
| Java |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2008,2009 IITP RAS
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* 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-1307 USA
*
* Authors: Kirill Andreev <andreev@iitp.ru>
*/
#include "hwmp-protocol.h"
#include "hwmp-protocol-mac.h"
#include "hwmp-tag.h"
#include "hwmp-rtable.h"
#include "ns3/log.h"
#include "ns3/simulator.h"
#include "ns3/packet.h"
#include "ns3/mesh-point-device.h"
#include "ns3/wifi-net-device.h"
#include "ns3/mesh-point-device.h"
#include "ns3/mesh-wifi-interface-mac.h"
#include "ns3/random-variable-stream.h"
#include "airtime-metric.h"
#include "ie-dot11s-preq.h"
#include "ie-dot11s-prep.h"
#include "ns3/trace-source-accessor.h"
#include "ie-dot11s-perr.h"
#include "ns3/arp-l3-protocol.h"
#include "ns3/ipv4-l3-protocol.h"
#include "ns3/udp-l4-protocol.h"
#include "ns3/tcp-l4-protocol.h"
#include "ns3/arp-header.h"
#include "ns3/ipv4-header.h"
#include "ns3/tcp-header.h"
#include "ns3/udp-header.h"
#include "ns3/rhoSigma-tag.h"
#include "ns3/llc-snap-header.h"
#include "ns3/wifi-mac-trailer.h"
#include "dot11s-mac-header.h"
NS_LOG_COMPONENT_DEFINE ("HwmpProtocol");
namespace ns3 {
namespace dot11s {
NS_OBJECT_ENSURE_REGISTERED (HwmpProtocol)
;
/* integration/qng.c
*
* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough
*
* 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 3 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//#include <config.h>
#include <math.h>
#include <float.h>
TypeId
HwmpProtocol::GetTypeId ()
{
static TypeId tid = TypeId ("ns3::dot11s::HwmpProtocol")
.SetParent<MeshL2RoutingProtocol> ()
.AddConstructor<HwmpProtocol> ()
.AddAttribute ( "RandomStart",
"Random delay at first proactive PREQ",
TimeValue (Seconds (0.1)),
MakeTimeAccessor (
&HwmpProtocol::m_randomStart),
MakeTimeChecker ()
)
.AddAttribute ( "MaxQueueSize",
"Maximum number of packets we can store when resolving route",
UintegerValue (255),
MakeUintegerAccessor (
&HwmpProtocol::m_maxQueueSize),
MakeUintegerChecker<uint16_t> (1)
)
.AddAttribute ( "Dot11MeshHWMPmaxPREQretries",
"Maximum number of retries before we suppose the destination to be unreachable",
UintegerValue (3),
MakeUintegerAccessor (
&HwmpProtocol::m_dot11MeshHWMPmaxPREQretries),
MakeUintegerChecker<uint8_t> (1)
)
.AddAttribute ( "Dot11MeshHWMPnetDiameterTraversalTime",
"Time we suppose the packet to go from one edge of the network to another",
TimeValue (MicroSeconds (1024*100)),
MakeTimeAccessor (
&HwmpProtocol::m_dot11MeshHWMPnetDiameterTraversalTime),
MakeTimeChecker ()
)
.AddAttribute ( "Dot11MeshHWMPpreqMinInterval",
"Minimal interval between to successive PREQs",
TimeValue (MicroSeconds (1024*100)),
MakeTimeAccessor (
&HwmpProtocol::m_dot11MeshHWMPpreqMinInterval),
MakeTimeChecker ()
)
.AddAttribute ( "Dot11MeshHWMPperrMinInterval",
"Minimal interval between to successive PREQs",
TimeValue (MicroSeconds (1024*100)),
MakeTimeAccessor (&HwmpProtocol::m_dot11MeshHWMPperrMinInterval),
MakeTimeChecker ()
)
.AddAttribute ( "Dot11MeshHWMPactiveRootTimeout",
"Lifetime of poractive routing information",
TimeValue (MicroSeconds (1024*5000)),
MakeTimeAccessor (
&HwmpProtocol::m_dot11MeshHWMPactiveRootTimeout),
MakeTimeChecker ()
)
.AddAttribute ( "Dot11MeshHWMPactivePathTimeout",
"Lifetime of reactive routing information",
TimeValue (MicroSeconds (1024*5000)),
MakeTimeAccessor (
&HwmpProtocol::m_dot11MeshHWMPactivePathTimeout),
MakeTimeChecker ()
)
.AddAttribute ( "Dot11MeshHWMPpathToRootInterval",
"Interval between two successive proactive PREQs",
TimeValue (MicroSeconds (1024*2000)),
MakeTimeAccessor (
&HwmpProtocol::m_dot11MeshHWMPpathToRootInterval),
MakeTimeChecker ()
)
.AddAttribute ( "Dot11MeshHWMPrannInterval",
"Lifetime of poractive routing information",
TimeValue (MicroSeconds (1024*5000)),
MakeTimeAccessor (
&HwmpProtocol::m_dot11MeshHWMPrannInterval),
MakeTimeChecker ()
)
.AddAttribute ( "MaxTtl",
"Initial value of Time To Live field",
UintegerValue (32),
MakeUintegerAccessor (
&HwmpProtocol::m_maxTtl),
MakeUintegerChecker<uint8_t> (2)
)
.AddAttribute ( "UnicastPerrThreshold",
"Maximum number of PERR receivers, when we send a PERR as a chain of unicasts",
UintegerValue (32),
MakeUintegerAccessor (
&HwmpProtocol::m_unicastPerrThreshold),
MakeUintegerChecker<uint8_t> (1)
)
.AddAttribute ( "UnicastPreqThreshold",
"Maximum number of PREQ receivers, when we send a PREQ as a chain of unicasts",
UintegerValue (1),
MakeUintegerAccessor (
&HwmpProtocol::m_unicastPreqThreshold),
MakeUintegerChecker<uint8_t> (1)
)
.AddAttribute ( "UnicastDataThreshold",
"Maximum number ofbroadcast receivers, when we send a broadcast as a chain of unicasts",
UintegerValue (1),
MakeUintegerAccessor (
&HwmpProtocol::m_unicastDataThreshold),
MakeUintegerChecker<uint8_t> (1)
)
.AddAttribute ( "DoFlag",
"Destination only HWMP flag",
BooleanValue (true),
MakeBooleanAccessor (
&HwmpProtocol::m_doFlag),
MakeBooleanChecker ()
)
.AddAttribute ( "RfFlag",
"Reply and forward flag",
BooleanValue (false),
MakeBooleanAccessor (
&HwmpProtocol::m_rfFlag),
MakeBooleanChecker ()
)
.AddTraceSource ( "RouteDiscoveryTime",
"The time of route discovery procedure",
MakeTraceSourceAccessor (
&HwmpProtocol::m_routeDiscoveryTimeCallback)
)
//by hadi
.AddAttribute ( "VBMetricMargin",
"VBMetricMargin",
UintegerValue (2),
MakeUintegerAccessor (
&HwmpProtocol::m_VBMetricMargin),
MakeUintegerChecker<uint32_t> (1)
)
.AddAttribute ( "Gppm",
"G Packets Per Minutes",
UintegerValue (3600),
MakeUintegerAccessor (
&HwmpProtocol::m_Gppm),
MakeUintegerChecker<uint32_t> (1)
)
.AddTraceSource ( "TransmittingFromSource",
"",
MakeTraceSourceAccessor (
&HwmpProtocol::m_txed4mSourceCallback)
)
.AddTraceSource ( "WannaTransmittingFromSource",
"",
MakeTraceSourceAccessor (
&HwmpProtocol::m_wannaTx4mSourceCallback)
)
.AddTraceSource( "CbrCnnStateChanged",
"",
MakeTraceSourceAccessor(
&HwmpProtocol::m_CbrCnnStateChanged))
.AddTraceSource( "PacketBufferredAtSource",
"",
MakeTraceSourceAccessor(
&HwmpProtocol::m_packetBufferredAtSource))
;
return tid;
}
HwmpProtocol::HwmpProtocol () :
m_dataSeqno (1),
m_hwmpSeqno (1),
m_preqId (0),
m_rtable (CreateObject<HwmpRtable> ()),
m_randomStart (Seconds (0.1)),
m_maxQueueSize (255),
m_dot11MeshHWMPmaxPREQretries (3),
m_dot11MeshHWMPnetDiameterTraversalTime (MicroSeconds (1024*100)),
m_dot11MeshHWMPpreqMinInterval (MicroSeconds (1024*100)),
m_dot11MeshHWMPperrMinInterval (MicroSeconds (1024*100)),
m_dot11MeshHWMPactiveRootTimeout (MicroSeconds (1024*5000)),
m_dot11MeshHWMPactivePathTimeout (MicroSeconds (1024*5000)),
m_dot11MeshHWMPpathToRootInterval (MicroSeconds (1024*2000)),
m_dot11MeshHWMPrannInterval (MicroSeconds (1024*5000)),
m_isRoot (false),
m_maxTtl (32),
m_unicastPerrThreshold (32),
m_unicastPreqThreshold (1),
m_unicastDataThreshold (1),
m_doFlag (true),
m_rfFlag (false),
m_VBMetricMargin(2)
{
NS_LOG_FUNCTION_NOARGS ();
m_noDataPacketYet=true;
m_energyPerByte=0;
m_coefficient = CreateObject<UniformRandomVariable> ();
}
HwmpProtocol::~HwmpProtocol ()
{
NS_LOG_FUNCTION_NOARGS ();
}
void
HwmpProtocol::DoInitialize ()
{
m_coefficient->SetAttribute ("Max", DoubleValue (m_randomStart.GetSeconds ()));
if (m_isRoot)
{
SetRoot ();
}
Simulator::Schedule(Seconds(0.5),&HwmpProtocol::CheckCbrRoutes4Expiration,this);//hadi eo94
m_interfaces.begin ()->second->SetEnergyChangeCallback (MakeCallback(&HwmpProtocol::EnergyChange,this));
m_interfaces.begin ()->second->SetGammaChangeCallback (MakeCallback(&HwmpProtocol::GammaChange,this));
m_rtable->setSystemB (m_interfaces.begin ()->second->GetEres ());
m_rtable->setBPrim (m_rtable->systemB ());
m_rtable->setSystemBMax (m_interfaces.begin ()->second->GetBatteryCapacity ());
m_rtable->setBPrimMax (m_rtable->systemBMax ());
m_rtable->setAssignedGamma (0);
m_rtable->setGppm (m_Gppm);
GammaChange (m_rtable->systemGamma (),m_totalSimulationTime);
m_rtable->UpdateToken ();
}
void
HwmpProtocol::DoDispose ()
{
NS_LOG_FUNCTION_NOARGS ();
for (std::map<Mac48Address, PreqEvent>::iterator i = m_preqTimeouts.begin (); i != m_preqTimeouts.end (); i++)
{
i->second.preqTimeout.Cancel ();
}
m_proactivePreqTimer.Cancel ();
m_preqTimeouts.clear ();
m_lastDataSeqno.clear ();
m_hwmpSeqnoMetricDatabase.clear ();
for (std::vector<CnnBasedPreqEvent>::iterator cbpei = m_cnnBasedPreqTimeouts.begin (); cbpei != m_cnnBasedPreqTimeouts.end (); cbpei++)
{
cbpei->preqTimeout.Cancel();
}
m_cnnBasedPreqTimeouts.clear();
for(std::vector<DelayedPrepStruct>::iterator dpsi=m_delayedPrepStruct.begin ();dpsi!=m_delayedPrepStruct.end ();dpsi++)
{
dpsi->prepTimeout.Cancel ();
}
m_delayedPrepStruct.clear ();
m_interfaces.clear ();
m_rqueue.clear ();
m_rtable = 0;
m_mp = 0;
}
bool
HwmpProtocol::RequestRoute (
uint32_t sourceIface,
const Mac48Address source,
const Mac48Address destination,
Ptr<const Packet> constPacket,
uint16_t protocolType, //ethrnet 'Protocol' field
MeshL2RoutingProtocol::RouteReplyCallback routeReply
)
{
Ptr <Packet> packet = constPacket->Copy ();
HwmpTag tag;
if (sourceIface == GetMeshPoint ()->GetIfIndex ())
{
// packet from level 3
if (packet->PeekPacketTag (tag))
{
NS_FATAL_ERROR ("HWMP tag has come with a packet from upper layer. This must not occur...");
}
//Filling TAG:
if (destination == Mac48Address::GetBroadcast ())
{
tag.SetSeqno (m_dataSeqno++);
}
tag.SetTtl (m_maxTtl);
}
else
{
if (!packet->RemovePacketTag (tag))
{
NS_FATAL_ERROR ("HWMP tag is supposed to be here at this point.");
}
tag.DecrementTtl ();
if (tag.GetTtl () == 0)
{
m_stats.droppedTtl++;
return false;
}
}
if (destination == Mac48Address::GetBroadcast ())
{
m_stats.txBroadcast++;
m_stats.txBytes += packet->GetSize ();
//channel IDs where we have already sent broadcast:
std::vector<uint16_t> channels;
for (HwmpProtocolMacMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin++)
{
bool shouldSend = true;
for (std::vector<uint16_t>::const_iterator chan = channels.begin (); chan != channels.end (); chan++)
{
if ((*chan) == plugin->second->GetChannelId ())
{
shouldSend = false;
}
}
if (!shouldSend)
{
continue;
}
channels.push_back (plugin->second->GetChannelId ());
std::vector<Mac48Address> receivers = GetBroadcastReceivers (plugin->first);
for (std::vector<Mac48Address>::const_iterator i = receivers.begin (); i != receivers.end (); i++)
{
Ptr<Packet> packetCopy = packet->Copy ();
//
// 64-bit Intel valgrind complains about tag.SetAddress (*i). It
// likes this just fine.
//
Mac48Address address = *i;
tag.SetAddress (address);
packetCopy->AddPacketTag (tag);
routeReply (true, packetCopy, source, destination, protocolType, plugin->first);
}
}
}
else
{
return ForwardUnicast (sourceIface, source, destination, packet, protocolType, routeReply, tag.GetTtl ());
}
return true;
}
bool
HwmpProtocol::RemoveRoutingStuff (uint32_t fromIface, const Mac48Address source,
const Mac48Address destination, Ptr<Packet> packet, uint16_t& protocolType)
{
HwmpTag tag;
if (!packet->RemovePacketTag (tag))
{
NS_FATAL_ERROR ("HWMP tag must exist when packet received from the network");
}
return true;
}
bool
HwmpProtocol::ForwardUnicast (uint32_t sourceIface, const Mac48Address source, const Mac48Address destination,
Ptr<Packet> packet, uint16_t protocolType, RouteReplyCallback routeReply, uint32_t ttl)
{
RhoSigmaTag rsTag;
packet->RemovePacketTag (rsTag);
Ptr<Packet> pCopy=packet->Copy();
uint8_t cnnType;//1:mac only, 2:ip only , 3:ip port
Ipv4Address srcIpv4Addr;
Ipv4Address dstIpv4Addr;
uint16_t srcPort;
uint16_t dstPort;
if(protocolType==ArpL3Protocol::PROT_NUMBER)
{
ArpHeader arpHdr;
pCopy->RemoveHeader(arpHdr);
srcIpv4Addr = arpHdr.GetSourceIpv4Address();
dstIpv4Addr = arpHdr.GetDestinationIpv4Address();
cnnType=HwmpRtable::CNN_TYPE_IP_ONLY;
// NS_LOG_HADI(m_address << " ARP packet have seen");
NS_ASSERT(true);
}
else if(protocolType==Ipv4L3Protocol::PROT_NUMBER)
{
Ipv4Header ipv4Hdr;
pCopy->RemoveHeader(ipv4Hdr);
srcIpv4Addr = ipv4Hdr.GetSource();
dstIpv4Addr = ipv4Hdr.GetDestination();
uint8_t protocol = ipv4Hdr.GetProtocol();
if(protocol==TcpL4Protocol::PROT_NUMBER)
{
TcpHeader tcpHdr;
pCopy->RemoveHeader (tcpHdr);
srcPort=tcpHdr.GetSourcePort ();
dstPort=tcpHdr.GetDestinationPort ();
cnnType=HwmpRtable::CNN_TYPE_PKT_BASED;
}
else if(protocol==UdpL4Protocol::PROT_NUMBER)
{
UdpHeader udpHdr;
pCopy->RemoveHeader(udpHdr);
srcPort=udpHdr.GetSourcePort();
dstPort=udpHdr.GetDestinationPort();
cnnType=HwmpRtable::CNN_TYPE_IP_PORT;
// NS_LOG_HADI(m_address << " UDP packet have seen " << source << "->" << destination << " " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
}
else
{
cnnType=HwmpRtable::CNN_TYPE_IP_ONLY;
// NS_LOG_HADI(m_address << " non TCP or UDP packet have seen");
NS_ASSERT(true);
}
}
else
{
cnnType=HwmpRtable::CNN_TYPE_MAC_ONLY;
// NS_LOG_HADI(m_address << " non IP packet have seen");
NS_ASSERT(true);
}
if((source==GetAddress())&&(cnnType==HwmpRtable::CNN_TYPE_IP_PORT)){
NS_LOG_ROUTING("hwmp forwardUnicast4mSource " << (int)packet->GetUid() << " " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " " << (int)rsTag.GetRho () << " " << (int)rsTag.GetSigma () << " " << rsTag.GetStopTime ());
m_wannaTx4mSourceCallback();
}
NS_ASSERT (destination != Mac48Address::GetBroadcast ());
NS_ASSERT(cnnType==HwmpRtable::CNN_TYPE_IP_PORT);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
if(cnnType==HwmpRtable::CNN_TYPE_IP_PORT){
CbrConnectionsVector::iterator nrccvi=std::find(m_notRoutedCbrConnections.begin(),m_notRoutedCbrConnections.end(),connection);
if(nrccvi!=m_notRoutedCbrConnections.end()){
if(source==GetAddress()){
NS_LOG_ROUTING("hwmp cnnRejectedDrop " << (int)packet->GetUid() << " " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
}
return false;
}
}
HwmpRtable::CnnBasedLookupResult cnnBasedResult = m_rtable->LookupCnnBasedReactive(destination,source,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
NS_LOG_DEBUG ("Requested src = "<<source<<", dst = "<<destination<<", I am "<<GetAddress ()<<", RA = "<<cnnBasedResult.retransmitter);
HwmpTag tag;
tag.SetAddress (cnnBasedResult.retransmitter);
tag.SetTtl (ttl);
//seqno and metric is not used;
packet->AddPacketTag (tag);
if (cnnBasedResult.retransmitter != Mac48Address::GetBroadcast ())
{
if(source==GetAddress())
{
NS_LOG_ROUTING("tx4mSource " << (int)packet->GetUid());
NS_LOG_CAC("tx4mSource " << srcIpv4Addr << ":" << srcPort << "=>" << dstIpv4Addr << ":" << dstPort << " " << (int)packet->GetUid());
m_txed4mSourceCallback();
SourceCbrRouteExtend (destination,source,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
}
else
{
NS_LOG_CAC("forwardViaIntermediate " << srcIpv4Addr << ":" << srcPort << "=>" << dstIpv4Addr << ":" << dstPort << " " << (int)packet->GetUid());
CbrRouteExtend(destination,source,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
}
//reply immediately:
//routeReply (true, packet, source, destination, protocolType, cnnBasedResult.ifIndex);
NS_LOG_TB("queuing packet in TBVB queue for send " << (int)packet->GetUid ());
m_rtable->QueueCnnBasedPacket (destination,source,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort,packet,protocolType,cnnBasedResult.ifIndex,routeReply);
m_stats.txUnicast++;
m_stats.txBytes += packet->GetSize ();
return true;
}
if (sourceIface != GetMeshPoint ()->GetIfIndex ())
{
//Start path error procedure:
NS_LOG_DEBUG ("Must Send PERR");
m_stats.totalDropped++;
return false;
}
//Request a destination:
if (CnnBasedShouldSendPreq (rsTag, destination, source, cnnType, srcIpv4Addr, dstIpv4Addr, srcPort, dstPort))
{
NS_LOG_ROUTING("sendingPathRequest " << source << " " << destination);
uint32_t originator_seqno = GetNextHwmpSeqno ();
uint32_t dst_seqno = 0;
m_stats.initiatedPreq++;
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
if(m_routingType==2)
i->second->RequestDestination (destination, originator_seqno, dst_seqno, cnnType, srcIpv4Addr, dstIpv4Addr, srcPort, dstPort,rsTag.GetRho (), rsTag.GetSigma (), rsTag.GetStopTime (), rsTag.delayBound (), rsTag.maxPktSize (), 0x7fffffff,0x7fffffff,0x7fffffff);
else
i->second->RequestDestination (destination, originator_seqno, dst_seqno, cnnType, srcIpv4Addr, dstIpv4Addr, srcPort, dstPort,rsTag.GetRho (), rsTag.GetSigma (), rsTag.GetStopTime (),rsTag.delayBound (), rsTag.maxPktSize (), 0,0,0);
}
}
QueuedPacket pkt;
pkt.pkt = packet;
pkt.dst = destination;
pkt.src = source;
pkt.protocol = protocolType;
pkt.reply = routeReply;
pkt.inInterface = sourceIface;
pkt.cnnType=cnnType;
pkt.srcIpv4Addr=srcIpv4Addr;
pkt.dstIpv4Addr=dstIpv4Addr;
pkt.srcPort=srcPort;
pkt.dstPort=dstPort;
if (QueuePacket (pkt))
{
if((source==GetAddress ())&&(cnnType==HwmpRtable::CNN_TYPE_IP_PORT))
m_packetBufferredAtSource(packet);
m_stats.totalQueued++;
return true;
}
else
{
m_stats.totalDropped++;
return false;
}
}
void
HwmpProtocol::ReceivePreq (IePreq preq, Mac48Address from, uint32_t interface, Mac48Address fromMp, uint32_t metric)
{
preq.IncrementMetric (metric);
NS_LOG_ROUTING("receivePreq " << from << " " << (int)preq.GetGammaPrim () << " " << (int)preq.GetBPrim () << " " << (int)preq.GetTotalE () << " " << (int)preq.GetMetric ());
//acceptance cretirea:
// bool duplicatePreq=false;
//bool freshInfo (true);
for(std::vector<CnnBasedSeqnoMetricDatabase>::iterator i=m_hwmpSeqnoMetricDatabase.begin();i!=m_hwmpSeqnoMetricDatabase.end();i++)
{
if(
(i->originatorAddress==preq.GetOriginatorAddress()) &&
(i->cnnType==preq.GetCnnType()) &&
(i->srcIpv4Addr==preq.GetSrcIpv4Addr()) &&
(i->srcPort==preq.GetSrcPort()) &&
(i->dstIpv4Addr==preq.GetDstIpv4Addr()) &&
(i->dstPort==preq.GetDstPort())
)
{
// duplicatePreq=true;
NS_LOG_ROUTING("duplicatePreq " << (int)i->originatorSeqNumber << " " << (int)preq.GetOriginatorSeqNumber ());
if ((int32_t)(i->originatorSeqNumber - preq.GetOriginatorSeqNumber ()) > 0)
{
return;
}
if (i->originatorSeqNumber == preq.GetOriginatorSeqNumber ())
{
//freshInfo = false;
if((m_routingType==1)||(m_routingType==2))
{
NS_LOG_ROUTING("checking prev " << i->bPrim << " " << i->gammaPrim << " " << i->totalE << " " << preq.GetBPrim () << " " << preq.GetGammaPrim () << " " << (int)preq.GetTotalE () << " " << (int)m_VBMetricMargin);
if((i->totalE+m_VBMetricMargin >= preq.GetTotalE ())&&(i->totalE <= preq.GetTotalE ()+m_VBMetricMargin))
{
if((i->metric+m_VBMetricMargin*10 >= preq.GetMetric ())&&(i->metric <= preq.GetMetric ()+m_VBMetricMargin*10))
{
if(m_routingType==1)
{
if(i->bPrim<=preq.GetBPrim ())
{
NS_LOG_ROUTING("b1 rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
else
{
if(i->bPrim>=preq.GetBPrim ())
{
NS_LOG_ROUTING("b2 rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
}
else if (i->metric <= preq.GetMetric ())
{
NS_LOG_ROUTING("metric rejected " << (int)i->metric << " " << (int)preq.GetMetric ());
return;
}
}
else
if(m_routingType==1)
{
if(i->totalE<=preq.GetTotalE ())
{
NS_LOG_ROUTING("totalE1 rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
else
{
if(i->totalE>=preq.GetTotalE ())
{
NS_LOG_ROUTING("totalE2 rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
/*NS_LOG_ROUTING("checking prev " << (int)i->metric << " " << (int)preq.GetMetric () << " " << (int)m_VBMetricMargin);
if ((i->metric+m_VBMetricMargin >= preq.GetMetric ())&&(i->metric <= preq.GetMetric ()+m_VBMetricMargin))
{
// check energy metric
NS_LOG_ROUTING("in margin with one prev preq " << (int)i->metric << " " << (int)preq.GetMetric () << " " << (int)m_VBMetricMargin);
if((i->bPrim+i->gammaPrim*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ())>=(preq.GetBPrim ()+preq.GetGammaPrim ()*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ()))
{
NS_LOG_ROUTING("bgamma rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
else if (i->metric <= preq.GetMetric ())
{
NS_LOG_ROUTING("metric rejected " << (int)i->metric << " " << (int)preq.GetMetric ());
return;
}*/
}
else
{
if (i->metric <= preq.GetMetric ())
{
NS_LOG_ROUTING("metric rejected " << (int)i->metric << " " << (int)preq.GetMetric ());
return;
}
}
}
m_hwmpSeqnoMetricDatabase.erase (i);
break;
}
}
CnnBasedSeqnoMetricDatabase newDb;
newDb.originatorAddress=preq.GetOriginatorAddress();
newDb.originatorSeqNumber=preq.GetOriginatorSeqNumber();
newDb.metric=preq.GetMetric();
newDb.cnnType=preq.GetCnnType();
newDb.srcIpv4Addr=preq.GetSrcIpv4Addr();
newDb.dstIpv4Addr=preq.GetDstIpv4Addr();
newDb.srcPort=preq.GetSrcPort();
newDb.dstPort=preq.GetDstPort();
newDb.gammaPrim=preq.GetGammaPrim ();
newDb.bPrim=preq.GetBPrim ();
newDb.totalE=preq.GetTotalE ();
m_hwmpSeqnoMetricDatabase.push_back(newDb);
std::vector<Ptr<DestinationAddressUnit> > destinations = preq.GetDestinationList ();
//Add reverse path to originator:
m_rtable->AddCnnBasedReversePath (preq.GetOriginatorAddress(),from,interface,preq.GetCnnType(),preq.GetSrcIpv4Addr(),preq.GetDstIpv4Addr(),preq.GetSrcPort(),preq.GetDstPort(),Seconds(1),preq.GetOriginatorSeqNumber());
//Add reactive path to originator:
for (std::vector<Ptr<DestinationAddressUnit> >::const_iterator i = destinations.begin (); i != destinations.end (); i++)
{
NS_LOG_ROUTING("receivePReq " << preq.GetOriginatorAddress() << " " << from << " " << (*i)->GetDestinationAddress ());
std::vector<Ptr<DestinationAddressUnit> > preqDestinations = preq.GetDestinationList ();
Mac48Address preqDstMac;
if(preqDestinations.size ()==1){
std::vector<Ptr<DestinationAddressUnit> >::const_iterator preqDstMacIt =preqDestinations.begin ();
preqDstMac=(*preqDstMacIt)->GetDestinationAddress();
}else{
preqDstMac=GetAddress ();
}
if ((*i)->GetDestinationAddress () == GetAddress ())
{
// if(!duplicatePreq)
{
if(m_doCAC)
{
// calculate total needed energy for entire connection lifetime and needed energy for bursts.
double totalEnergyNeeded = (m_rtable->m_maxEnergyPerDataPacket+m_rtable->m_maxEnergyPerAckPacket)*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ()*(preq.GetRho ()/60)*m_rtable->m_energyAlpha;
double burstEnergyNeeded = (m_rtable->m_maxEnergyPerDataPacket+m_rtable->m_maxEnergyPerAckPacket)*preq.GetSigma ()*m_rtable->m_energyAlpha;
double energyUntilEndOfConnection = m_rtable->bPrim ()+ m_rtable->gammaPrim ()*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ();
NS_LOG_ROUTING("ReceivePreqCACdestination " << m_rtable->m_maxEnergyPerDataPacket << " " << m_rtable->m_maxEnergyPerAckPacket << " " << (int)preq.GetRho () << " " << (int)preq.GetSigma () << " " << preq.GetStopTime () << " ; " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << energyUntilEndOfConnection << " " << m_rtable->bPrim ());
if( ( ( m_rtable->bPrim ()< burstEnergyNeeded ) || ( energyUntilEndOfConnection < totalEnergyNeeded ) ) || (!m_interfaces.begin()->second->HasEnoughCapacity4NewConnection(preq.GetOriginatorAddress (),preqDstMac,preq.GetHopCount (),from,preq.GetRho ()) ) )// CAC check
{
NS_LOG_ROUTING("cac rejected the connection " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << energyUntilEndOfConnection << " " << m_rtable->bPrim ());
return;
}
}
else
{
if(m_rtable->bPrim ()<=0)
{
NS_LOG_ROUTING("bPrim()<=0_1 rejected the connection " << m_rtable->bPrim ());
return;
}
}
}
NS_LOG_ROUTING("schedule2sendPrep");
Schedule2sendPrep (
GetAddress (),
preq.GetOriginatorAddress (),
preq.GetMetric(),
preq.GetCnnType(),
preq.GetSrcIpv4Addr(),
preq.GetDstIpv4Addr(),
preq.GetSrcPort(),
preq.GetDstPort(),
preq.GetRho (),
preq.GetSigma (),
preq.GetStopTime (),
preq.GetDelayBound (),
preq.GetMaxPktSize (),
preq.GetOriginatorSeqNumber (),
GetNextHwmpSeqno (),
preq.GetLifetime (),
interface
);
//NS_ASSERT (m_rtable->LookupReactive (preq.GetOriginatorAddress ()).retransmitter != Mac48Address::GetBroadcast ());
preq.DelDestinationAddressElement ((*i)->GetDestinationAddress ());
continue;
}
else
{
// if(!duplicatePreq)
{
if(m_doCAC)
{
// calculate total needed energy for entire connection lifetime and needed energy for bursts.
double totalEnergyNeeded = 2 * (m_rtable->m_maxEnergyPerDataPacket+m_rtable->m_maxEnergyPerAckPacket)*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ()*(preq.GetRho ()/60)*m_rtable->m_energyAlpha;
double burstEnergyNeeded = 2 * (m_rtable->m_maxEnergyPerDataPacket+m_rtable->m_maxEnergyPerAckPacket)*preq.GetSigma ()*m_rtable->m_energyAlpha;
double energyUntilEndOfConnection = m_rtable->bPrim ()+ m_rtable->gammaPrim ()*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ();
NS_LOG_ROUTING("ReceivePreqCACintermediate " << m_rtable->m_maxEnergyPerDataPacket << " " << m_rtable->m_maxEnergyPerAckPacket << " " << (int)preq.GetRho () << " " << (int)preq.GetSigma () << " " << preq.GetStopTime () << " ; " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << energyUntilEndOfConnection << " " << m_rtable->bPrim ());
if( ( ( m_rtable->bPrim ()< burstEnergyNeeded ) || ( energyUntilEndOfConnection < totalEnergyNeeded ) ) || (!m_interfaces.begin()->second->HasEnoughCapacity4NewConnection(preq.GetOriginatorAddress (),preqDstMac,preq.GetHopCount (),from,preq.GetRho ()) ) )// CAC check
{
NS_LOG_ROUTING("cac rejected the connection " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << energyUntilEndOfConnection << " " << m_rtable->bPrim ());
return;
}
}
else
{
if(m_rtable->bPrim ()<=0)
{
NS_LOG_ROUTING("bPrim()<=0_2 rejected the connection " << m_rtable->bPrim ());
return;
}
}
}
if(m_routingType==1)
preq.UpdateVBMetricSum (m_rtable->gammaPrim (),m_rtable->bPrim ());
else if(m_routingType==2)
preq.UpdateVBMetricMin (m_rtable->gammaPrim (),m_rtable->bPrim ());
}
}
NS_LOG_DEBUG ("I am " << GetAddress () << "Accepted preq from address" << from << ", preq:" << preq);
//check if must retransmit:
if (preq.GetDestCount () == 0)
{
return;
}
//Forward PREQ to all interfaces:
NS_LOG_DEBUG ("I am " << GetAddress () << "retransmitting PREQ:" << preq);
NS_LOG_ROUTING("forwardPreq");
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
i->second->SendPreq (preq);
}
}
void
HwmpProtocol::Schedule2sendPrep(
Mac48Address src,
Mac48Address dst,
uint32_t initMetric,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort,
uint16_t rho,
uint16_t sigma,
Time stopTime,
Time delayBound,
uint16_t maxPktSize,
uint32_t originatorDsn,
uint32_t destinationSN,
uint32_t lifetime,
uint32_t interface)
{
for(std::vector<DelayedPrepStruct>::iterator dpsi=m_delayedPrepStruct.begin ();dpsi!=m_delayedPrepStruct.end ();dpsi++)
{
if(
(dpsi->destination==dst) &&
(dpsi->source==src) &&
(dpsi->cnnType==cnnType) &&
(dpsi->srcIpv4Addr==srcIpv4Addr) &&
(dpsi->dstIpv4Addr==dstIpv4Addr) &&
(dpsi->srcPort==srcPort) &&
(dpsi->dstPort==dstPort)
)
{
NS_LOG_ROUTING("scheduledBefore");
return;
}
}
DelayedPrepStruct dps;
dps.destination=dst;
dps.source=src;
dps.cnnType=cnnType;
dps.srcIpv4Addr=srcIpv4Addr;
dps.dstIpv4Addr=dstIpv4Addr;
dps.srcPort=srcPort;
dps.dstPort=dstPort;
dps.rho=rho;
dps.sigma=sigma;
dps.stopTime=stopTime;
dps.delayBound=delayBound;
dps.maxPktSize=maxPktSize;
dps.initMetric=initMetric;
dps.originatorDsn=originatorDsn;
dps.destinationSN=destinationSN;
dps.lifetime=lifetime;
dps.interface=interface;
dps.whenScheduled=Simulator::Now();
dps.prepTimeout=Simulator::Schedule(Seconds (0.1),&HwmpProtocol::SendDelayedPrep,this,dps);
NS_LOG_ROUTING("scheduled for " << "1" << " seconds");
m_delayedPrepStruct.push_back (dps);
}
void
HwmpProtocol::SendDelayedPrep(DelayedPrepStruct dps)
{
NS_LOG_ROUTING("trying to send prep to " << dps.destination);
HwmpRtable::CnnBasedLookupResult result=m_rtable->LookupCnnBasedReverse(dps.destination,dps.cnnType,dps.srcIpv4Addr,dps.dstIpv4Addr,dps.srcPort,dps.dstPort);
if (result.retransmitter == Mac48Address::GetBroadcast ())
{
NS_LOG_ROUTING("cant find reverse path");
return;
}
//this is only for assigning a VB for this connection
if(!m_rtable->AddCnnBasedReactivePath (
dps.destination,
GetAddress (),
dps.source,
result.retransmitter,
dps.interface,
dps.cnnType,
dps.srcIpv4Addr,
dps.dstIpv4Addr,
dps.srcPort,
dps.dstPort,
dps.rho,
dps.sigma,
dps.stopTime,
dps.delayBound,
dps.maxPktSize,
Seconds (dps.lifetime),
dps.originatorDsn,
false,
m_doCAC))
{
return;
}
SendPrep (
GetAddress (),
dps.destination,
result.retransmitter,
dps.initMetric,
dps.cnnType,
dps.srcIpv4Addr,
dps.dstIpv4Addr,
dps.srcPort,
dps.dstPort,
dps.rho,
dps.sigma,
dps.stopTime,
dps.delayBound,
dps.maxPktSize,
dps.originatorDsn,
dps.destinationSN,
dps.lifetime,
dps.interface
);
NS_LOG_ROUTING("prep sent and AddCnnBasedReactivePath");
//std::vector<DelayedPrepStruct>::iterator it=std::find(m_delayedPrepStruct.begin (),m_delayedPrepStruct.end (),dps);
//if(it!=m_delayedPrepStruct.end ())
// m_delayedPrepStruct.erase (it); // we dont erase the entry from the vector cause of preventing to send prep twice
}
void
HwmpProtocol::ReceivePrep (IePrep prep, Mac48Address from, uint32_t interface, Mac48Address fromMp, uint32_t metric)
{
NS_LOG_UNCOND( Simulator::Now ().GetSeconds () << " " << (int)Simulator::GetContext () << " prep received " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort());
NS_LOG_ROUTING("prep received");
if(prep.GetDestinationAddress () == GetAddress ()){
NS_LOG_ROUTING("prep received for me");
CbrConnection connection;
connection.cnnType=prep.GetCnnType ();
connection.dstIpv4Addr=prep.GetDstIpv4Addr ();
connection.srcIpv4Addr=prep.GetSrcIpv4Addr ();
connection.dstPort=prep.GetDstPort ();
connection.srcPort=prep.GetSrcPort ();
CbrConnectionsVector::iterator nrccvi=std::find(m_notRoutedCbrConnections.begin(),m_notRoutedCbrConnections.end(),connection);
if(nrccvi!=m_notRoutedCbrConnections.end()){
NS_LOG_ROUTING("sourceCnnHasDropped " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort() << " " << from);
return;
}
}
prep.IncrementMetric (metric);
//acceptance cretirea:
bool freshInfo (true);
std::vector<CnnBasedSeqnoMetricDatabase>::iterator dbit;
for(std::vector<CnnBasedSeqnoMetricDatabase>::iterator i=m_hwmpSeqnoMetricDatabase.begin();i!=m_hwmpSeqnoMetricDatabase.end();i++)
{
if(
(i->originatorAddress==prep.GetOriginatorAddress()) &&
(i->cnnType==prep.GetCnnType()) &&
(i->srcIpv4Addr==prep.GetSrcIpv4Addr()) &&
(i->srcPort==prep.GetSrcPort()) &&
(i->dstIpv4Addr==prep.GetDstIpv4Addr()) &&
(i->dstPort==prep.GetDstPort())
)
{
if ((int32_t)(i->destinationSeqNumber - prep.GetDestinationSeqNumber()) > 0)
{
/*BarghiTest 1392/08/02 add for get result start*/
//commented for hadireports std::cout << "t:" << Simulator::Now() << " ,Im " << m_address << " returning because of older preq" << std::endl;
/*BarghiTest 1392/08/02 add for get result end*/
NS_LOG_ROUTING("hwmp droppedCPREP seqnum " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort() << " " << from);
return;
}
dbit=i;
freshInfo=false;
break;
}
}
if(freshInfo)
{
CnnBasedSeqnoMetricDatabase newDb;
newDb.originatorAddress=prep.GetOriginatorAddress();
newDb.originatorSeqNumber=prep.GetOriginatorSeqNumber();
newDb.destinationAddress=prep.GetDestinationAddress();
newDb.destinationSeqNumber=prep.GetDestinationSeqNumber();
newDb.metric=prep.GetMetric();
newDb.cnnType=prep.GetCnnType();
newDb.srcIpv4Addr=prep.GetSrcIpv4Addr();
newDb.dstIpv4Addr=prep.GetDstIpv4Addr();
newDb.srcPort=prep.GetSrcPort();
newDb.dstPort=prep.GetDstPort();
m_hwmpSeqnoMetricDatabase.push_back(newDb);
if (prep.GetDestinationAddress () == GetAddress ())
{
if(!m_rtable->AddCnnBasedReactivePath (
prep.GetOriginatorAddress (),
from,
GetAddress (),
GetAddress (),
interface,
prep.GetCnnType (),
prep.GetSrcIpv4Addr (),
prep.GetDstIpv4Addr (),
prep.GetSrcPort (),
prep.GetDstPort (),
prep.GetRho (),
prep.GetSigma (),
prep.GetStopTime (),
prep.GetDelayBound (),
prep.GetMaxPktSize (),
Seconds (10000),
prep.GetOriginatorSeqNumber (),
false,
m_doCAC))
{
NS_LOG_ROUTING("cac rejected at sourceWhenPrepReceived the connection ");
CbrConnection connection;
connection.destination=prep.GetOriginatorAddress ();
connection.source=GetAddress ();
connection.cnnType=prep.GetCnnType ();
connection.dstIpv4Addr=prep.GetDstIpv4Addr ();
connection.srcIpv4Addr=prep.GetSrcIpv4Addr ();
connection.dstPort=prep.GetDstPort ();
connection.srcPort=prep.GetSrcPort ();
m_notRoutedCbrConnections.push_back (connection);
return;
}
m_rtable->AddPrecursor (prep.GetDestinationAddress (), interface, from,
MicroSeconds (prep.GetLifetime () * 1024));
/*if (result.retransmitter != Mac48Address::GetBroadcast ())
{
m_rtable->AddPrecursor (prep.GetOriginatorAddress (), interface, result.retransmitter,
result.lifetime);
}*/
//ReactivePathResolved (prep.GetOriginatorAddress ());
NS_LOG_ROUTING("hwmp routing pathResolved and AddCnnBasedReactivePath " << prep.GetOriginatorAddress ()<< " " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort() << " " << from);
CnnBasedReactivePathResolved(prep.GetOriginatorAddress (),GetAddress (),prep.GetCnnType (),prep.GetSrcIpv4Addr (),prep.GetDstIpv4Addr (),prep.GetSrcPort (),prep.GetDstPort ());
m_CbrCnnStateChanged(prep.GetSrcIpv4Addr(),prep.GetDstIpv4Addr(),prep.GetSrcPort(),prep.GetDstPort(),true);
InsertCbrCnnAtSourceIntoSourceCbrCnnsVector(prep.GetOriginatorAddress(),GetAddress (),prep.GetCnnType(),prep.GetSrcIpv4Addr(),prep.GetDstIpv4Addr(),prep.GetSrcPort(),prep.GetDstPort(),GetAddress(),from);
NS_LOG_DEBUG ("I am "<<GetAddress ()<<", resolved "<<prep.GetOriginatorAddress ());
return;
}
}else
{
NS_LOG_ROUTING("duplicate prep not allowed!");
NS_ASSERT(false);
}
//update routing info
//Now add a path to destination and add precursor to source
NS_LOG_DEBUG ("I am " << GetAddress () << ", received prep from " << prep.GetOriginatorAddress () << ", receiver was:" << from);
HwmpRtable::CnnBasedLookupResult result=m_rtable->LookupCnnBasedReverse(prep.GetDestinationAddress(),prep.GetCnnType(),prep.GetSrcIpv4Addr(),prep.GetDstIpv4Addr(),prep.GetSrcPort(),prep.GetDstPort());
if (result.retransmitter == Mac48Address::GetBroadcast ())
{
NS_LOG_ROUTING("cant find reverse path 2");
return;
}
if(!m_rtable->AddCnnBasedReactivePath ( prep.GetOriginatorAddress (),
from,
prep.GetDestinationAddress (),
result.retransmitter,
interface,
prep.GetCnnType (),
prep.GetSrcIpv4Addr (),
prep.GetDstIpv4Addr (),
prep.GetSrcPort (),
prep.GetDstPort (),
prep.GetRho (),
prep.GetSigma (),
prep.GetStopTime (),
prep.GetDelayBound (),
prep.GetMaxPktSize (),
Seconds (10000),
prep.GetOriginatorSeqNumber (),
true,
m_doCAC))
{
NS_LOG_ROUTING("cnnRejectedAtPrep " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort());
return;
}
InsertCbrCnnIntoCbrCnnsVector(prep.GetOriginatorAddress(),prep.GetDestinationAddress(),prep.GetCnnType(),prep.GetSrcIpv4Addr(),prep.GetDstIpv4Addr(),prep.GetSrcPort(),prep.GetDstPort(),result.retransmitter,from);
//Forward PREP
NS_LOG_ROUTING("hwmp routing pathSaved and AddCnnBasedReactivePath and SendPrep " << prep.GetOriginatorAddress () << " " << result.retransmitter << " " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort() << " " << from << " " << result.retransmitter);
HwmpProtocolMacMap::const_iterator prep_sender = m_interfaces.find (result.ifIndex);
NS_ASSERT (prep_sender != m_interfaces.end ());
prep_sender->second->SendPrep (prep, result.retransmitter);
}
void
HwmpProtocol::InsertCbrCnnAtSourceIntoSourceCbrCnnsVector(
Mac48Address destination,
Mac48Address source,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort,
Mac48Address prevHop,
Mac48Address nextHop
){
NS_LOG_ROUTING("hwmp inserting cnn into cnnsvector at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
connection.prevMac=prevHop;
connection.nextMac=nextHop;
connection.whenExpires=Simulator::Now()+MilliSeconds(SOURCE_CBR_ROUTE_EXPIRE_MILLISECONDS);
CbrConnectionsVector::iterator ccvi=std::find(m_sourceCbrConnections.begin(),m_sourceCbrConnections.end(),connection);
if(ccvi==m_sourceCbrConnections.end()){
NS_LOG_ROUTING("hwmp new, inserted at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
m_sourceCbrConnections.push_back(connection);
}else{
NS_LOG_ROUTING("hwmp exist, expiration extended at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
ccvi->whenExpires=Simulator::Now()+Seconds(SOURCE_CBR_ROUTE_EXPIRE_MILLISECONDS);
}
}
void
HwmpProtocol::SourceCbrRouteExtend(
Mac48Address destination,
Mac48Address source,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
){
NS_LOG_ROUTING("hwmp cbr route extend at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
CbrConnectionsVector::iterator ccvi=std::find(m_sourceCbrConnections.begin(),m_sourceCbrConnections.end(),connection);
if(ccvi!=m_sourceCbrConnections.end()){
NS_LOG_ROUTING("hwmp cbr route really found and extended at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << ccvi->nextMac << " p " << ccvi->prevMac);
ccvi->whenExpires=Simulator::Now()+MilliSeconds(SOURCE_CBR_ROUTE_EXPIRE_MILLISECONDS);
}else{
NS_LOG_ROUTING("hwmp cbr route not found and not extended at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
}
}
void
HwmpProtocol::InsertCbrCnnIntoCbrCnnsVector(
Mac48Address destination,
Mac48Address source,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort,
Mac48Address prevHop,
Mac48Address nextHop
){
NS_LOG_ROUTING("hwmp inserting cnn into cnnsvector " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
connection.prevMac=prevHop;
connection.nextMac=nextHop;
connection.whenExpires=Simulator::Now()+Seconds(CBR_ROUTE_EXPIRE_SECONDS);
//connection.routeExpireEvent=Simulator::Schedule(Seconds(CBR_ROUTE_EXPIRE_SECONDS),&HwmpProtocol::CbrRouteExpire,this,connection);
CbrConnectionsVector::iterator ccvi=std::find(m_cbrConnections.begin(),m_cbrConnections.end(),connection);
if(ccvi==m_cbrConnections.end()){
NS_LOG_ROUTING("hwmp new, inserted " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
m_cbrConnections.push_back(connection);
}else{
NS_LOG_ROUTING("hwmp exist, expiration extended " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
ccvi->whenExpires=Simulator::Now()+Seconds(CBR_ROUTE_EXPIRE_SECONDS);
ccvi->nextMac=nextHop;
ccvi->prevMac=prevHop;
//m_cbrConnections.erase(ccvi);
//m_cbrConnections.push_back(connection);
//ccvi->routeExpireEvent.Cancel();
//ccvi->routeExpireEvent=Simulator::Schedule(Seconds(CBR_ROUTE_EXPIRE_SECONDS),&HwmpProtocol::CbrRouteExpire,this,connection);
}
}
void
HwmpProtocol::CbrRouteExtend(
Mac48Address destination,
Mac48Address source,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
){
NS_LOG_ROUTING("hwmp cbr route extend " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
CbrConnectionsVector::iterator ccvi=std::find(m_cbrConnections.begin(),m_cbrConnections.end(),connection);
if(ccvi!=m_cbrConnections.end()){
NS_LOG_ROUTING("hwmp cbr route really found and extended " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << ccvi->nextMac << " p " << ccvi->prevMac);
ccvi->whenExpires=Simulator::Now()+Seconds(CBR_ROUTE_EXPIRE_SECONDS);
//ccvi->routeExpireEvent.Cancel();
//ccvi->routeExpireEvent=Simulator::Schedule(Seconds(CBR_ROUTE_EXPIRE_SECONDS),&HwmpProtocol::CbrRouteExpire,this,connection);
}else{
NS_LOG_ROUTING("hwmp cbr route not found and not extended " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
}
}
void
HwmpProtocol::CbrRouteExpire(CbrConnection cbrCnn){
NS_LOG_ROUTING("hwmp cbr route expired " << cbrCnn.srcIpv4Addr << ":" << (int)cbrCnn.srcPort << "=>" << cbrCnn.dstIpv4Addr << ":" << (int)cbrCnn.dstPort << " n " << cbrCnn.nextMac << " p " << cbrCnn.prevMac);
CbrConnectionsVector::iterator ccvi=std::find(m_cbrConnections.begin(),m_cbrConnections.end(),cbrCnn);
if(ccvi!=m_cbrConnections.end()){
m_cbrConnections.erase(ccvi);
m_rtable->DeleteCnnBasedReactivePath(cbrCnn.destination,cbrCnn.source,cbrCnn.cnnType,cbrCnn.srcIpv4Addr,cbrCnn.dstIpv4Addr,cbrCnn.srcPort,cbrCnn.dstPort);
NS_LOG_ROUTING("hwmp cbr route deleted " << cbrCnn.srcIpv4Addr << ":" << (int)cbrCnn.srcPort << "=>" << cbrCnn.dstIpv4Addr << ":" << (int)cbrCnn.dstPort << " n " << cbrCnn.nextMac << " p " << cbrCnn.prevMac);
}
}
void
HwmpProtocol::CheckCbrRoutes4Expiration(){
CbrConnectionsVector tempvector;
bool changed=false;
for(CbrConnectionsVector::iterator ccvi=m_cbrConnections.begin();ccvi!=m_cbrConnections.end();ccvi++){
if(Simulator::Now()<ccvi->whenExpires){
tempvector.push_back(*ccvi);
}else{
changed = true;
m_rtable->DeleteCnnBasedReactivePath(ccvi->destination,ccvi->source,ccvi->cnnType,ccvi->srcIpv4Addr,ccvi->dstIpv4Addr,ccvi->srcPort,ccvi->dstPort);
NS_LOG_ROUTING("hwmp cbr route expired and deleted " << ccvi->srcIpv4Addr << ":" << (int)ccvi->srcPort << "=>" << ccvi->dstIpv4Addr << ":" << (int)ccvi->dstPort << " n " << ccvi->nextMac << " p " << ccvi->prevMac);
}
}
if(changed){
m_cbrConnections.clear();
m_cbrConnections=tempvector;
NS_LOG_ROUTING("hwmp num connections " << m_cbrConnections.size());
}
tempvector.clear();
for(CbrConnectionsVector::iterator ccvi=m_sourceCbrConnections.begin();ccvi!=m_sourceCbrConnections.end();ccvi++){
if(Simulator::Now()<ccvi->whenExpires){
tempvector.push_back(*ccvi);
}else{
changed = true;
m_CbrCnnStateChanged(ccvi->srcIpv4Addr,ccvi->dstIpv4Addr,ccvi->srcPort,ccvi->dstPort,false);
}
}
if(changed){
m_sourceCbrConnections.clear();
m_sourceCbrConnections=tempvector;
}
Simulator::Schedule(MilliSeconds(50),&HwmpProtocol::CheckCbrRoutes4Expiration,this);
}
void
HwmpProtocol::ReceivePerr (std::vector<FailedDestination> destinations, Mac48Address from, uint32_t interface, Mac48Address fromMp)
{
//Acceptance cretirea:
NS_LOG_DEBUG ("I am "<<GetAddress ()<<", received PERR from "<<from);
std::vector<FailedDestination> retval;
HwmpRtable::LookupResult result;
for (unsigned int i = 0; i < destinations.size (); i++)
{
result = m_rtable->LookupReactiveExpired (destinations[i].destination);
if (!(
(result.retransmitter != from) ||
(result.ifIndex != interface) ||
((int32_t)(result.seqnum - destinations[i].seqnum) > 0)
))
{
retval.push_back (destinations[i]);
}
}
if (retval.size () == 0)
{
return;
}
ForwardPathError (MakePathError (retval));
}
void
HwmpProtocol::SendPrep (Mac48Address src,
Mac48Address dst,
Mac48Address retransmitter,
uint32_t initMetric,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort,
uint16_t rho,
uint16_t sigma,
Time stopTime, Time delayBound, uint16_t maxPktSize,
uint32_t originatorDsn,
uint32_t destinationSN,
uint32_t lifetime,
uint32_t interface)
{
IePrep prep;
prep.SetHopcount (0);
prep.SetTtl (m_maxTtl);
prep.SetDestinationAddress (dst);
prep.SetDestinationSeqNumber (destinationSN);
prep.SetLifetime (lifetime);
prep.SetMetric (initMetric);
prep.SetCnnParams(cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
prep.SetRho (rho);
prep.SetSigma (sigma);
prep.SetStopTime (stopTime);
prep.SetDelayBound (delayBound);
prep.SetMaxPktSize (maxPktSize);
prep.SetOriginatorAddress (src);
prep.SetOriginatorSeqNumber (originatorDsn);
HwmpProtocolMacMap::const_iterator prep_sender = m_interfaces.find (interface);
NS_ASSERT (prep_sender != m_interfaces.end ());
prep_sender->second->SendPrep (prep, retransmitter);
m_stats.initiatedPrep++;
}
bool
HwmpProtocol::Install (Ptr<MeshPointDevice> mp)
{
m_mp = mp;
std::vector<Ptr<NetDevice> > interfaces = mp->GetInterfaces ();
for (std::vector<Ptr<NetDevice> >::const_iterator i = interfaces.begin (); i != interfaces.end (); i++)
{
// Checking for compatible net device
Ptr<WifiNetDevice> wifiNetDev = (*i)->GetObject<WifiNetDevice> ();
if (wifiNetDev == 0)
{
return false;
}
Ptr<MeshWifiInterfaceMac> mac = wifiNetDev->GetMac ()->GetObject<MeshWifiInterfaceMac> ();
if (mac == 0)
{
return false;
}
// Installing plugins:
Ptr<HwmpProtocolMac> hwmpMac = Create<HwmpProtocolMac> (wifiNetDev->GetIfIndex (), this);
m_interfaces[wifiNetDev->GetIfIndex ()] = hwmpMac;
mac->InstallPlugin (hwmpMac);
//Installing airtime link metric:
Ptr<AirtimeLinkMetricCalculator> metric = CreateObject <AirtimeLinkMetricCalculator> ();
mac->SetLinkMetricCallback (MakeCallback (&AirtimeLinkMetricCalculator::CalculateMetric, metric));
}
mp->SetRoutingProtocol (this);
// Mesh point aggregates all installed protocols
mp->AggregateObject (this);
m_address = Mac48Address::ConvertFrom (mp->GetAddress ()); // address;
return true;
}
void
HwmpProtocol::PeerLinkStatus (Mac48Address meshPointAddress, Mac48Address peerAddress, uint32_t interface, bool status)
{
if (status)
{
return;
}
std::vector<FailedDestination> destinations = m_rtable->GetUnreachableDestinations (peerAddress);
InitiatePathError (MakePathError (destinations));
}
void
HwmpProtocol::SetNeighboursCallback (Callback<std::vector<Mac48Address>, uint32_t> cb)
{
m_neighboursCallback = cb;
}
bool
HwmpProtocol::DropDataFrame (uint32_t seqno, Mac48Address source)
{
if (source == GetAddress ())
{
return true;
}
std::map<Mac48Address, uint32_t,std::less<Mac48Address> >::const_iterator i = m_lastDataSeqno.find (source);
if (i == m_lastDataSeqno.end ())
{
m_lastDataSeqno[source] = seqno;
}
else
{
if ((int32_t)(i->second - seqno) >= 0)
{
return true;
}
m_lastDataSeqno[source] = seqno;
}
return false;
}
HwmpProtocol::PathError
HwmpProtocol::MakePathError (std::vector<FailedDestination> destinations)
{
PathError retval;
//HwmpRtable increments a sequence number as written in 11B.9.7.2
retval.receivers = GetPerrReceivers (destinations);
if (retval.receivers.size () == 0)
{
return retval;
}
m_stats.initiatedPerr++;
for (unsigned int i = 0; i < destinations.size (); i++)
{
retval.destinations.push_back (destinations[i]);
m_rtable->DeleteReactivePath (destinations[i].destination);
}
return retval;
}
void
HwmpProtocol::InitiatePathError (PathError perr)
{
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
std::vector<Mac48Address> receivers_for_interface;
for (unsigned int j = 0; j < perr.receivers.size (); j++)
{
if (i->first == perr.receivers[j].first)
{
receivers_for_interface.push_back (perr.receivers[j].second);
}
}
i->second->InitiatePerr (perr.destinations, receivers_for_interface);
}
}
void
HwmpProtocol::ForwardPathError (PathError perr)
{
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
std::vector<Mac48Address> receivers_for_interface;
for (unsigned int j = 0; j < perr.receivers.size (); j++)
{
if (i->first == perr.receivers[j].first)
{
receivers_for_interface.push_back (perr.receivers[j].second);
}
}
i->second->ForwardPerr (perr.destinations, receivers_for_interface);
}
}
std::vector<std::pair<uint32_t, Mac48Address> >
HwmpProtocol::GetPerrReceivers (std::vector<FailedDestination> failedDest)
{
HwmpRtable::PrecursorList retval;
for (unsigned int i = 0; i < failedDest.size (); i++)
{
HwmpRtable::PrecursorList precursors = m_rtable->GetPrecursors (failedDest[i].destination);
m_rtable->DeleteReactivePath (failedDest[i].destination);
m_rtable->DeleteProactivePath (failedDest[i].destination);
for (unsigned int j = 0; j < precursors.size (); j++)
{
retval.push_back (precursors[j]);
}
}
//Check if we have dublicates in retval and precursors:
for (unsigned int i = 0; i < retval.size (); i++)
{
for (unsigned int j = i+1; j < retval.size (); j++)
{
if (retval[i].second == retval[j].second)
{
retval.erase (retval.begin () + j);
}
}
}
return retval;
}
std::vector<Mac48Address>
HwmpProtocol::GetPreqReceivers (uint32_t interface)
{
std::vector<Mac48Address> retval;
if (!m_neighboursCallback.IsNull ())
{
retval = m_neighboursCallback (interface);
}
if ((retval.size () >= m_unicastPreqThreshold) || (retval.size () == 0))
{
retval.clear ();
retval.push_back (Mac48Address::GetBroadcast ());
}
return retval;
}
std::vector<Mac48Address>
HwmpProtocol::GetBroadcastReceivers (uint32_t interface)
{
std::vector<Mac48Address> retval;
if (!m_neighboursCallback.IsNull ())
{
retval = m_neighboursCallback (interface);
}
if ((retval.size () >= m_unicastDataThreshold) || (retval.size () == 0))
{
retval.clear ();
retval.push_back (Mac48Address::GetBroadcast ());
}
return retval;
}
bool
HwmpProtocol::QueuePacket (QueuedPacket packet)
{
if (m_rqueue.size () >= m_maxQueueSize)
{
NS_LOG_CAC("packetDroppedAtHwmp " << (int)packet.pkt->GetUid () << " " << m_rqueue.size ());
return false;
}
m_rqueue.push_back (packet);
return true;
}
HwmpProtocol::QueuedPacket
HwmpProtocol::DequeueFirstPacketByCnnParams (
Mac48Address dst,
Mac48Address src,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
)
{
QueuedPacket retval;
retval.pkt = 0;
NS_LOG_ROUTING("hwmp DequeueFirstPacketByCnnParams " << (int)m_rqueue.size());
for (std::vector<QueuedPacket>::iterator i = m_rqueue.begin (); i != m_rqueue.end (); i++)
{
if (
((*i).dst == dst) &&
((*i).src == src) &&
((*i).cnnType == cnnType) &&
((*i).srcIpv4Addr == srcIpv4Addr) &&
((*i).dstIpv4Addr == dstIpv4Addr) &&
((*i).srcPort == srcPort) &&
((*i).dstPort == dstPort)
)
{
retval = (*i);
m_rqueue.erase (i);
break;
}
}
//std::cout << Simulator::Now().GetSeconds() << " " << m_address << " SourceQueueSize " << m_rqueue.size() << std::endl;
return retval;
}
HwmpProtocol::QueuedPacket
HwmpProtocol::DequeueFirstPacketByDst (Mac48Address dst)
{
QueuedPacket retval;
retval.pkt = 0;
for (std::vector<QueuedPacket>::iterator i = m_rqueue.begin (); i != m_rqueue.end (); i++)
{
if ((*i).dst == dst)
{
retval = (*i);
m_rqueue.erase (i);
break;
}
}
return retval;
}
HwmpProtocol::QueuedPacket
HwmpProtocol::DequeueFirstPacket ()
{
QueuedPacket retval;
retval.pkt = 0;
if (m_rqueue.size () != 0)
{
retval = m_rqueue[0];
m_rqueue.erase (m_rqueue.begin ());
}
return retval;
}
void
HwmpProtocol::ReactivePathResolved (Mac48Address dst)
{
std::map<Mac48Address, PreqEvent>::iterator i = m_preqTimeouts.find (dst);
if (i != m_preqTimeouts.end ())
{
m_routeDiscoveryTimeCallback (Simulator::Now () - i->second.whenScheduled);
}
HwmpRtable::LookupResult result = m_rtable->LookupReactive (dst);
NS_ASSERT (result.retransmitter != Mac48Address::GetBroadcast ());
//Send all packets stored for this destination
QueuedPacket packet = DequeueFirstPacketByDst (dst);
while (packet.pkt != 0)
{
if(packet.src==GetAddress()){
NS_LOG_ROUTING("tx4mSource2 " << (int)packet.pkt->GetUid());
}
//set RA tag for retransmitter:
HwmpTag tag;
packet.pkt->RemovePacketTag (tag);
tag.SetAddress (result.retransmitter);
packet.pkt->AddPacketTag (tag);
m_stats.txUnicast++;
m_stats.txBytes += packet.pkt->GetSize ();
packet.reply (true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
packet = DequeueFirstPacketByDst (dst);
}
}
void
HwmpProtocol::CnnBasedReactivePathResolved (
Mac48Address dst,
Mac48Address src,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
)
{
HwmpRtable::CnnBasedLookupResult result = m_rtable->LookupCnnBasedReactive(dst,src,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
NS_ASSERT (result.retransmitter != Mac48Address::GetBroadcast ());
//Send all packets stored for this destination
QueuedPacket packet = DequeueFirstPacketByCnnParams (dst,src,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
while (packet.pkt != 0)
{
if((packet.src==GetAddress())&&(cnnType==HwmpRtable::CNN_TYPE_IP_PORT)){
NS_LOG_ROUTING("tx4mSource2 " << (int)packet.pkt->GetUid());
NS_LOG_CAC("tx4mSource2 " << (int)packet.pkt->GetUid());
m_txed4mSourceCallback();
}
//set RA tag for retransmitter:
HwmpTag tag;
packet.pkt->RemovePacketTag (tag);
tag.SetAddress (result.retransmitter);
packet.pkt->AddPacketTag (tag);
m_stats.txUnicast++;
m_stats.txBytes += packet.pkt->GetSize ();
//packet.reply (true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
// m_rtable->QueueCnnBasedPacket (packet.dst,packet.src,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort,packet.pkt,packet.protocol,result.ifIndex,packet.reply);
packet = DequeueFirstPacketByCnnParams (dst,src,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
}
}
void
HwmpProtocol::ProactivePathResolved ()
{
//send all packets to root
HwmpRtable::LookupResult result = m_rtable->LookupProactive ();
NS_ASSERT (result.retransmitter != Mac48Address::GetBroadcast ());
QueuedPacket packet = DequeueFirstPacket ();
while (packet.pkt != 0)
{
//set RA tag for retransmitter:
HwmpTag tag;
if (!packet.pkt->RemovePacketTag (tag))
{
NS_FATAL_ERROR ("HWMP tag must be present at this point");
}
tag.SetAddress (result.retransmitter);
packet.pkt->AddPacketTag (tag);
m_stats.txUnicast++;
m_stats.txBytes += packet.pkt->GetSize ();
packet.reply (true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
packet = DequeueFirstPacket ();
}
}
bool
HwmpProtocol::ShouldSendPreq (Mac48Address dst)
{
std::map<Mac48Address, PreqEvent>::const_iterator i = m_preqTimeouts.find (dst);
if (i == m_preqTimeouts.end ())
{
m_preqTimeouts[dst].preqTimeout = Simulator::Schedule (
Time (m_dot11MeshHWMPnetDiameterTraversalTime * 2),
&HwmpProtocol::RetryPathDiscovery, this, dst, 1);
m_preqTimeouts[dst].whenScheduled = Simulator::Now ();
return true;
}
return false;
}
bool
HwmpProtocol::CnnBasedShouldSendPreq (
RhoSigmaTag rsTag,
Mac48Address dst,
Mac48Address src,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
)
{
for(std::vector<CnnBasedPreqEvent>::iterator cbpei = m_cnnBasedPreqTimeouts.begin (); cbpei != m_cnnBasedPreqTimeouts.end (); cbpei++)
{
if(
(cbpei->destination==dst) &&
(cbpei->source==src) &&
(cbpei->cnnType==cnnType) &&
(cbpei->srcIpv4Addr==srcIpv4Addr) &&
(cbpei->dstIpv4Addr==dstIpv4Addr) &&
(cbpei->srcPort==srcPort) &&
(cbpei->dstPort==dstPort)
)
{
return false;
}
}
if(src==GetAddress ())
{
if(m_doCAC)
{
// calculate total needed energy for entire connection lifetime and needed energy for bursts.
double totalEnergyNeeded = (m_rtable->m_maxEnergyPerDataPacket+m_rtable->m_maxEnergyPerAckPacket)*(rsTag.GetStopTime ()-Simulator::Now ()).GetSeconds ()*(rsTag.GetRho ()/60)*m_rtable->m_energyAlpha;
double burstEnergyNeeded = (m_rtable->m_maxEnergyPerDataPacket+m_rtable->m_maxEnergyPerAckPacket)*rsTag.GetSigma ()*m_rtable->m_energyAlpha;
double energyUntilEndOfConnection = m_rtable->bPrim ()+ m_rtable->gammaPrim ()*(rsTag.GetStopTime ()-Simulator::Now ()).GetSeconds ();
NS_LOG_ROUTING("ReceiveFirstPacketCACCheck " << m_rtable->m_maxEnergyPerDataPacket << " " << m_rtable->m_maxEnergyPerAckPacket << " " << (int)rsTag.GetRho () << " " << (int)rsTag.GetSigma () << " " << rsTag.GetStopTime () << " ; " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << energyUntilEndOfConnection << " " << m_rtable->bPrim ());
if( ( ( m_rtable->bPrim () < burstEnergyNeeded ) || ( energyUntilEndOfConnection < totalEnergyNeeded ) ) || (!m_interfaces.begin ()->second->HasEnoughCapacity4NewConnection (GetAddress (),dst,0,GetAddress (),rsTag.GetRho ())) )// CAC check
{
NS_LOG_ROUTING("cac rejected at source the connection " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << energyUntilEndOfConnection << " " << m_rtable->bPrim ());
CbrConnection connection;
connection.destination=dst;
connection.source=src;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
m_notRoutedCbrConnections.push_back (connection);
return false;
}
}
else
{
if(m_rtable->bPrim ()<=0)
{
NS_LOG_ROUTING("bPrim()<=0 rejected at source the connection " << m_rtable->bPrim ());
CbrConnection connection;
connection.destination=dst;
connection.source=src;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
m_notRoutedCbrConnections.push_back (connection);
return false;
}
}
}
CnnBasedPreqEvent cbpe;
cbpe.destination=dst;
cbpe.source=src;
cbpe.cnnType=cnnType;
cbpe.srcIpv4Addr=srcIpv4Addr;
cbpe.dstIpv4Addr=dstIpv4Addr;
cbpe.srcPort=srcPort;
cbpe.dstPort=dstPort;
cbpe.rho=rsTag.GetRho ();
cbpe.sigma=rsTag.GetSigma ();
cbpe.stopTime=rsTag.GetStopTime ();
cbpe.delayBound=rsTag.delayBound ();
cbpe.maxPktSize=rsTag.maxPktSize ();
cbpe.whenScheduled=Simulator::Now();
cbpe.preqTimeout=Simulator::Schedule(
Time (m_dot11MeshHWMPnetDiameterTraversalTime * 2),
&HwmpProtocol::CnnBasedRetryPathDiscovery,this,cbpe,1);
m_cnnBasedPreqTimeouts.push_back(cbpe);
NS_LOG_ROUTING("need to send preq");
return true;
}
void
HwmpProtocol::RetryPathDiscovery (Mac48Address dst, uint8_t numOfRetry)
{
HwmpRtable::LookupResult result = m_rtable->LookupReactive (dst);
if (result.retransmitter == Mac48Address::GetBroadcast ())
{
result = m_rtable->LookupProactive ();
}
if (result.retransmitter != Mac48Address::GetBroadcast ())
{
std::map<Mac48Address, PreqEvent>::iterator i = m_preqTimeouts.find (dst);
NS_ASSERT (i != m_preqTimeouts.end ());
m_preqTimeouts.erase (i);
return;
}
if (numOfRetry > m_dot11MeshHWMPmaxPREQretries)
{
NS_LOG_ROUTING("givingUpPathRequest " << dst);
QueuedPacket packet = DequeueFirstPacketByDst (dst);
//purge queue and delete entry from retryDatabase
while (packet.pkt != 0)
{
m_stats.totalDropped++;
packet.reply (false, packet.pkt, packet.src, packet.dst, packet.protocol, HwmpRtable::MAX_METRIC);
packet = DequeueFirstPacketByDst (dst);
}
std::map<Mac48Address, PreqEvent>::iterator i = m_preqTimeouts.find (dst);
NS_ASSERT (i != m_preqTimeouts.end ());
m_routeDiscoveryTimeCallback (Simulator::Now () - i->second.whenScheduled);
m_preqTimeouts.erase (i);
return;
}
numOfRetry++;
uint32_t originator_seqno = GetNextHwmpSeqno ();
uint32_t dst_seqno = m_rtable->LookupReactiveExpired (dst).seqnum;
NS_LOG_ROUTING("retryPathRequest " << dst);
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
Ipv4Address tempadd;
if(m_routingType==2)
i->second->RequestDestination (dst, originator_seqno, dst_seqno,HwmpRtable::CNN_TYPE_PKT_BASED,tempadd,tempadd,0,0,0,0,Seconds (0),Seconds (0),0,0x7fffffff,0x7fffffff,0x7fffffff);
else
i->second->RequestDestination (dst, originator_seqno, dst_seqno,HwmpRtable::CNN_TYPE_PKT_BASED,tempadd,tempadd,0,0,0,0,Seconds (0),Seconds (0),0,0,0,0);
}
m_preqTimeouts[dst].preqTimeout = Simulator::Schedule (
Time ((2 * (numOfRetry + 1)) * m_dot11MeshHWMPnetDiameterTraversalTime),
&HwmpProtocol::RetryPathDiscovery, this, dst, numOfRetry);
}
void
HwmpProtocol::CnnBasedRetryPathDiscovery (
CnnBasedPreqEvent preqEvent,
uint8_t numOfRetry
)
{
HwmpRtable::CnnBasedLookupResult result = m_rtable->LookupCnnBasedReactive(preqEvent.destination,preqEvent.source,preqEvent.cnnType,preqEvent.srcIpv4Addr,preqEvent.dstIpv4Addr,preqEvent.srcPort,preqEvent.dstPort);
if (result.retransmitter != Mac48Address::GetBroadcast ())
{
for(std::vector<CnnBasedPreqEvent>::iterator cbpei = m_cnnBasedPreqTimeouts.begin (); cbpei != m_cnnBasedPreqTimeouts.end (); cbpei++)
{
if(
(cbpei->destination==preqEvent.destination) &&
(cbpei->source==preqEvent.source) &&
(cbpei->cnnType==preqEvent.cnnType) &&
(cbpei->srcIpv4Addr==preqEvent.srcIpv4Addr) &&
(cbpei->dstIpv4Addr==preqEvent.dstIpv4Addr) &&
(cbpei->srcPort==preqEvent.srcPort) &&
(cbpei->dstPort==preqEvent.dstPort)
)
{
m_cnnBasedPreqTimeouts.erase(cbpei);
return;
}
}
NS_ASSERT (false);
return;
}
if (numOfRetry > m_dot11MeshHWMPmaxPREQretries)
{
//hadireport reject connection
NS_LOG_ROUTING("hwmp connectionRejected " << preqEvent.destination << " " << preqEvent.srcIpv4Addr << ":" << (int)preqEvent.srcPort << "=>" << preqEvent.dstIpv4Addr << ":" << (int)preqEvent.dstPort);
QueuedPacket packet = DequeueFirstPacketByCnnParams (preqEvent.destination,preqEvent.source,preqEvent.cnnType,preqEvent.srcIpv4Addr,preqEvent.dstIpv4Addr,preqEvent.srcPort,preqEvent.dstPort);
CbrConnection connection;
connection.destination=preqEvent.destination;
connection.source=preqEvent.source;
connection.cnnType=preqEvent.cnnType;
connection.dstIpv4Addr=preqEvent.dstIpv4Addr;
connection.srcIpv4Addr=preqEvent.srcIpv4Addr;
connection.dstPort=preqEvent.dstPort;
connection.srcPort=preqEvent.srcPort;
CbrConnectionsVector::iterator nrccvi=std::find(m_notRoutedCbrConnections.begin(),m_notRoutedCbrConnections.end(),connection);
if(nrccvi==m_notRoutedCbrConnections.end()){
m_notRoutedCbrConnections.push_back(connection);
}
//purge queue and delete entry from retryDatabase
while (packet.pkt != 0)
{
if(packet.src==GetAddress()){
NS_LOG_ROUTING("hwmp noRouteDrop2 " << (int)packet.pkt->GetUid() << " " << preqEvent.srcIpv4Addr << ":" << (int)preqEvent.srcPort << "=>" << preqEvent.dstIpv4Addr << ":" << (int)preqEvent.dstPort);
}
m_stats.totalDropped++;
packet.reply (false, packet.pkt, packet.src, packet.dst, packet.protocol, HwmpRtable::MAX_METRIC);
packet = DequeueFirstPacketByCnnParams (preqEvent.destination,preqEvent.source,preqEvent.cnnType,preqEvent.srcIpv4Addr,preqEvent.dstIpv4Addr,preqEvent.srcPort,preqEvent.dstPort);
}
for(std::vector<CnnBasedPreqEvent>::iterator cbpei = m_cnnBasedPreqTimeouts.begin (); cbpei != m_cnnBasedPreqTimeouts.end (); cbpei++)
{
if(
(cbpei->destination==preqEvent.destination) &&
(cbpei->cnnType==preqEvent.cnnType) &&
(cbpei->srcIpv4Addr==preqEvent.srcIpv4Addr) &&
(cbpei->dstIpv4Addr==preqEvent.dstIpv4Addr) &&
(cbpei->srcPort==preqEvent.srcPort) &&
(cbpei->dstPort==preqEvent.dstPort)
)
{
m_cnnBasedPreqTimeouts.erase(cbpei);
return;
}
}
NS_ASSERT (false);
return;
}
numOfRetry++;
uint32_t originator_seqno = GetNextHwmpSeqno ();
uint32_t dst_seqno = 0;
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
if(m_routingType==2)
i->second->RequestDestination (preqEvent.destination, originator_seqno, dst_seqno, preqEvent.cnnType, preqEvent.srcIpv4Addr, preqEvent.dstIpv4Addr, preqEvent.srcPort, preqEvent.dstPort,preqEvent.rho,preqEvent.sigma,preqEvent.stopTime,preqEvent.delayBound,preqEvent.maxPktSize, 0x7fffffff,0x7fffffff,0x7fffffff);
else
i->second->RequestDestination (preqEvent.destination, originator_seqno, dst_seqno, preqEvent.cnnType, preqEvent.srcIpv4Addr, preqEvent.dstIpv4Addr, preqEvent.srcPort, preqEvent.dstPort,preqEvent.rho,preqEvent.sigma,preqEvent.stopTime,preqEvent.delayBound,preqEvent.maxPktSize, 0,0,0);
}
for(std::vector<CnnBasedPreqEvent>::iterator cbpei = m_cnnBasedPreqTimeouts.begin (); cbpei != m_cnnBasedPreqTimeouts.end (); cbpei++)
{
if(
(cbpei->destination==preqEvent.destination) &&
(cbpei->cnnType==preqEvent.cnnType) &&
(cbpei->srcIpv4Addr==preqEvent.srcIpv4Addr) &&
(cbpei->dstIpv4Addr==preqEvent.dstIpv4Addr) &&
(cbpei->srcPort==preqEvent.srcPort) &&
(cbpei->dstPort==preqEvent.dstPort)
)
{
cbpei->preqTimeout=Simulator::Schedule(
Time ((2 * (numOfRetry + 1)) * m_dot11MeshHWMPnetDiameterTraversalTime),
&HwmpProtocol::CnnBasedRetryPathDiscovery,this,(*cbpei),numOfRetry);
cbpei->whenScheduled=Simulator::Now();
return;
}
}
CnnBasedPreqEvent cbpe;
cbpe.destination=preqEvent.destination;
cbpe.cnnType=preqEvent.cnnType;
cbpe.srcIpv4Addr=preqEvent.srcIpv4Addr;
cbpe.dstIpv4Addr=preqEvent.dstIpv4Addr;
cbpe.srcPort=preqEvent.srcPort;
cbpe.dstPort=preqEvent.dstPort;
cbpe.whenScheduled=Simulator::Now();
cbpe.preqTimeout=Simulator::Schedule(
Time ((2 * (numOfRetry + 1)) * m_dot11MeshHWMPnetDiameterTraversalTime),
&HwmpProtocol::CnnBasedRetryPathDiscovery,this,cbpe,numOfRetry);
m_cnnBasedPreqTimeouts.push_back(cbpe);
}
//Proactive PREQ routines:
void
HwmpProtocol::SetRoot ()
{
Time randomStart = Seconds (m_coefficient->GetValue ());
m_proactivePreqTimer = Simulator::Schedule (randomStart, &HwmpProtocol::SendProactivePreq, this);
NS_LOG_DEBUG ("ROOT IS: " << m_address);
m_isRoot = true;
}
void
HwmpProtocol::UnsetRoot ()
{
m_proactivePreqTimer.Cancel ();
}
void
HwmpProtocol::SendProactivePreq ()
{
IePreq preq;
//By default: must answer
preq.SetHopcount (0);
preq.SetTTL (m_maxTtl);
preq.SetLifetime (m_dot11MeshHWMPactiveRootTimeout.GetMicroSeconds () /1024);
//\attention: do not forget to set originator address, sequence
//number and preq ID in HWMP-MAC plugin
preq.AddDestinationAddressElement (true, true, Mac48Address::GetBroadcast (), 0);
preq.SetOriginatorAddress (GetAddress ());
preq.SetPreqID (GetNextPreqId ());
preq.SetOriginatorSeqNumber (GetNextHwmpSeqno ());
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
i->second->SendPreq (preq);
}
m_proactivePreqTimer = Simulator::Schedule (m_dot11MeshHWMPpathToRootInterval, &HwmpProtocol::SendProactivePreq, this);
}
bool
HwmpProtocol::GetDoFlag ()
{
return m_doFlag;
}
bool
HwmpProtocol::GetRfFlag ()
{
return m_rfFlag;
}
Time
HwmpProtocol::GetPreqMinInterval ()
{
return m_dot11MeshHWMPpreqMinInterval;
}
Time
HwmpProtocol::GetPerrMinInterval ()
{
return m_dot11MeshHWMPperrMinInterval;
}
uint8_t
HwmpProtocol::GetMaxTtl ()
{
return m_maxTtl;
}
uint32_t
HwmpProtocol::GetNextPreqId ()
{
m_preqId++;
return m_preqId;
}
uint32_t
HwmpProtocol::GetNextHwmpSeqno ()
{
m_hwmpSeqno++;
return m_hwmpSeqno;
}
uint32_t
HwmpProtocol::GetActivePathLifetime ()
{
return m_dot11MeshHWMPactivePathTimeout.GetMicroSeconds () / 1024;
}
uint8_t
HwmpProtocol::GetUnicastPerrThreshold ()
{
return m_unicastPerrThreshold;
}
Mac48Address
HwmpProtocol::GetAddress ()
{
return m_address;
}
void
HwmpProtocol::EnergyChange (Ptr<Packet> packet,bool isAck, bool incDec, double energy, double remainedEnergy,uint32_t packetSize)
{
uint8_t cnnType;//1:mac only, 2:ip only , 3:ip port
Ipv4Address srcIpv4Addr;
Ipv4Address dstIpv4Addr;
uint16_t srcPort;
uint16_t dstPort;
if(packet!=0)
{
WifiMacHeader wmhdr;
packet->RemoveHeader (wmhdr);
WifiMacTrailer fcs;
packet->RemoveTrailer (fcs);
MeshHeader meshHdr;
packet->RemoveHeader (meshHdr);
LlcSnapHeader llc;
packet->RemoveHeader (llc);
NS_LOG_VB("rxtx packet llc protocol type " << llc.GetType ());
if(llc.GetType ()==Ipv4L3Protocol::PROT_NUMBER)
{
Ipv4Header ipv4Hdr;
packet->RemoveHeader(ipv4Hdr);
srcIpv4Addr = ipv4Hdr.GetSource();
dstIpv4Addr = ipv4Hdr.GetDestination();
uint8_t protocol = ipv4Hdr.GetProtocol();
if(protocol==TcpL4Protocol::PROT_NUMBER)
{
TcpHeader tcpHdr;
packet->RemoveHeader (tcpHdr);
srcPort=tcpHdr.GetSourcePort ();
dstPort=tcpHdr.GetDestinationPort ();
cnnType=HwmpRtable::CNN_TYPE_PKT_BASED;
}
else if(protocol==UdpL4Protocol::PROT_NUMBER)
{
UdpHeader udpHdr;
packet->RemoveHeader(udpHdr);
srcPort=udpHdr.GetSourcePort();
dstPort=udpHdr.GetDestinationPort();
cnnType=HwmpRtable::CNN_TYPE_IP_PORT;
}
else
{
cnnType=HwmpRtable::CNN_TYPE_MAC_ONLY;
}
}
else
{
cnnType=HwmpRtable::CNN_TYPE_MAC_ONLY;
}
}
double systemB=m_rtable->systemB ();
if(incDec)//increased
{
systemB+=energy;
if(systemB>m_rtable->systemBMax ())
systemB=m_rtable->systemBMax ();
if(packet==0)//increased by gamma or energyback
{
if(packetSize==0)//increased by gamma
{
m_rtable->TotalEnergyIncreasedByGamma (energy);
}
else//increased by collision energy back of other packets
{
m_rtable->ControlEnergyIncreasedByCollisionEnergyBack (energy);
}
}else//increased by collision energy back
{
m_rtable->ChangeEnergy4aConnection (cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort,energy,true);
}
}else//decreased
{
systemB-=energy;
if(systemB<0)
systemB=0;
if(packet==0)
{
if(packetSize!=0)//decreased by other types of packets
{
if(m_noDataPacketYet)
{
m_energyPerByte = 0.7 * m_energyPerByte + 0.3 * energy/packetSize;
m_rtable->SetMaxEnergyPerAckPacket (m_energyPerByte*14);
m_rtable->SetMaxEnergyPerDataPacket (m_energyPerByte*260);
//NS_LOG_VB("energyPerAckByte " << m_energyPerByte*14);
//NS_LOG_VB("energyPerDataByte " << m_energyPerByte*260);
}
}
m_rtable->ControlPacketsEnergyDecreased (energy);
}
else//decreased by data or ack for data packets
{
m_noDataPacketYet=false;
if(isAck )
{
if(energy > m_rtable->GetMaxEnergyPerAckPacket ())
m_rtable->SetMaxEnergyPerAckPacket (energy);
//NS_LOG_VB("energyPerAck " << energy);
}
else if(cnnType==HwmpRtable::CNN_TYPE_IP_PORT)
{
if(energy > m_rtable->GetMaxEnergyPerDataPacket ())
m_rtable->SetMaxEnergyPerDataPacket (energy);
//NS_LOG_VB("energyPerData " << energy);
}
if(cnnType==HwmpRtable::CNN_TYPE_IP_PORT)
{
m_rtable->ChangeEnergy4aConnection (cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort,energy,false);
}
else
{
m_rtable->ControlPacketsEnergyDecreased (energy);
}
}
}
if(std::abs(systemB-remainedEnergy)>1)
{
NS_LOG_VB("remainedEnergyError " << systemB << " " << remainedEnergy);
}
else
{
//NS_LOG_VB("remainedEnergy " << systemB << " " << remainedEnergy);
}
m_rtable->setSystemB (remainedEnergy);
}
void
HwmpProtocol::GammaChange(double gamma, double totalSimmTime)
{
m_totalSimulationTime=totalSimmTime;
double remainedSimulationTimeSeconds=m_totalSimulationTime-Simulator::Now ().GetSeconds ();
double remainedControlEnergyNeeded=remainedSimulationTimeSeconds*0.035;
//double remainedControlEnergyNeeded=remainedSimulationTimeSeconds*0;
double bPrim=m_rtable->bPrim ()+m_rtable->controlB ();
double gammaPrim=m_rtable->gammaPrim ()+m_rtable->controlGamma ();
double assignedGamma=m_rtable->assignedGamma ()-m_rtable->controlGamma ();
if(bPrim>=remainedControlEnergyNeeded)
{
m_rtable->setControlB (remainedControlEnergyNeeded);
m_rtable->setControlBMax (remainedControlEnergyNeeded);
m_rtable->setControlGamma (0);
bPrim-=remainedControlEnergyNeeded;
}
else
{
m_rtable->setControlB (bPrim);
m_rtable->setControlBMax (remainedControlEnergyNeeded);
bPrim=0;
double neededControlGamma=(remainedControlEnergyNeeded-bPrim)/remainedSimulationTimeSeconds;
if(gammaPrim>=neededControlGamma)
{
m_rtable->setControlGamma (neededControlGamma);
gammaPrim-=neededControlGamma;
assignedGamma+=neededControlGamma;
}
else
{
m_rtable->setControlGamma (gammaPrim);
assignedGamma+=gammaPrim;
gammaPrim=0;
}
}
m_rtable->setSystemGamma (gamma);
m_rtable->setBPrim (bPrim);
m_rtable->setGammaPrim (gammaPrim);
m_rtable->setAssignedGamma (assignedGamma);
NS_LOG_VB("GammaChange " << gamma << " " << totalSimmTime << " | " << m_rtable->systemGamma () << " " << m_rtable->bPrim () << " " << m_rtable->gammaPrim () << " " << m_rtable->assignedGamma () << " * " << m_rtable->controlGamma () << " " << m_rtable->controlB ());
}
//Statistics:
HwmpProtocol::Statistics::Statistics () :
txUnicast (0),
txBroadcast (0),
txBytes (0),
droppedTtl (0),
totalQueued (0),
totalDropped (0),
initiatedPreq (0),
initiatedPrep (0),
initiatedPerr (0)
{
}
void HwmpProtocol::Statistics::Print (std::ostream & os) const
{
os << "<Statistics "
"txUnicast=\"" << txUnicast << "\" "
"txBroadcast=\"" << txBroadcast << "\" "
"txBytes=\"" << txBytes << "\" "
"droppedTtl=\"" << droppedTtl << "\" "
"totalQueued=\"" << totalQueued << "\" "
"totalDropped=\"" << totalDropped << "\" "
"initiatedPreq=\"" << initiatedPreq << "\" "
"initiatedPrep=\"" << initiatedPrep << "\" "
"initiatedPerr=\"" << initiatedPerr << "\"/>" << std::endl;
}
void
HwmpProtocol::Report (std::ostream & os) const
{
os << "<Hwmp "
"address=\"" << m_address << "\"" << std::endl <<
"maxQueueSize=\"" << m_maxQueueSize << "\"" << std::endl <<
"Dot11MeshHWMPmaxPREQretries=\"" << (uint16_t)m_dot11MeshHWMPmaxPREQretries << "\"" << std::endl <<
"Dot11MeshHWMPnetDiameterTraversalTime=\"" << m_dot11MeshHWMPnetDiameterTraversalTime.GetSeconds () << "\"" << std::endl <<
"Dot11MeshHWMPpreqMinInterval=\"" << m_dot11MeshHWMPpreqMinInterval.GetSeconds () << "\"" << std::endl <<
"Dot11MeshHWMPperrMinInterval=\"" << m_dot11MeshHWMPperrMinInterval.GetSeconds () << "\"" << std::endl <<
"Dot11MeshHWMPactiveRootTimeout=\"" << m_dot11MeshHWMPactiveRootTimeout.GetSeconds () << "\"" << std::endl <<
"Dot11MeshHWMPactivePathTimeout=\"" << m_dot11MeshHWMPactivePathTimeout.GetSeconds () << "\"" << std::endl <<
"Dot11MeshHWMPpathToRootInterval=\"" << m_dot11MeshHWMPpathToRootInterval.GetSeconds () << "\"" << std::endl <<
"Dot11MeshHWMPrannInterval=\"" << m_dot11MeshHWMPrannInterval.GetSeconds () << "\"" << std::endl <<
"isRoot=\"" << m_isRoot << "\"" << std::endl <<
"maxTtl=\"" << (uint16_t)m_maxTtl << "\"" << std::endl <<
"unicastPerrThreshold=\"" << (uint16_t)m_unicastPerrThreshold << "\"" << std::endl <<
"unicastPreqThreshold=\"" << (uint16_t)m_unicastPreqThreshold << "\"" << std::endl <<
"unicastDataThreshold=\"" << (uint16_t)m_unicastDataThreshold << "\"" << std::endl <<
"doFlag=\"" << m_doFlag << "\"" << std::endl <<
"rfFlag=\"" << m_rfFlag << "\">" << std::endl;
m_stats.Print (os);
for (HwmpProtocolMacMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin++)
{
plugin->second->Report (os);
}
os << "</Hwmp>" << std::endl;
}
void
HwmpProtocol::ResetStats ()
{
m_stats = Statistics ();
for (HwmpProtocolMacMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin++)
{
plugin->second->ResetStats ();
}
}
int64_t
HwmpProtocol::AssignStreams (int64_t stream)
{
NS_LOG_FUNCTION (this << stream);
m_coefficient->SetStream (stream);
return 1;
}
double HwmpProtocol::GetSumRhoPps()
{
return m_rtable->GetSumRhoPps ();
}
double HwmpProtocol::GetSumGPps()
{
return m_rtable->GetSumGPps ();
}
HwmpProtocol::QueuedPacket::QueuedPacket () :
pkt (0),
protocol (0),
inInterface (0)
{
}
} // namespace dot11s
} // namespace ns3
| Java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.